Class DataDictionaryImpl

    • Field Detail

      • CFG_SYSTABLES_ID

        private static final java.lang.String CFG_SYSTABLES_ID
        See Also:
        Constant Field Values
      • CFG_SYSTABLES_INDEX1_ID

        private static final java.lang.String CFG_SYSTABLES_INDEX1_ID
        See Also:
        Constant Field Values
      • CFG_SYSTABLES_INDEX2_ID

        private static final java.lang.String CFG_SYSTABLES_INDEX2_ID
        See Also:
        Constant Field Values
      • CFG_SYSCOLUMNS_ID

        private static final java.lang.String CFG_SYSCOLUMNS_ID
        See Also:
        Constant Field Values
      • CFG_SYSCOLUMNS_INDEX1_ID

        private static final java.lang.String CFG_SYSCOLUMNS_INDEX1_ID
        See Also:
        Constant Field Values
      • CFG_SYSCOLUMNS_INDEX2_ID

        private static final java.lang.String CFG_SYSCOLUMNS_INDEX2_ID
        See Also:
        Constant Field Values
      • CFG_SYSCONGLOMERATES_ID

        private static final java.lang.String CFG_SYSCONGLOMERATES_ID
        See Also:
        Constant Field Values
      • CFG_SYSCONGLOMERATES_INDEX1_ID

        private static final java.lang.String CFG_SYSCONGLOMERATES_INDEX1_ID
        See Also:
        Constant Field Values
      • CFG_SYSCONGLOMERATES_INDEX2_ID

        private static final java.lang.String CFG_SYSCONGLOMERATES_INDEX2_ID
        See Also:
        Constant Field Values
      • CFG_SYSCONGLOMERATES_INDEX3_ID

        private static final java.lang.String CFG_SYSCONGLOMERATES_INDEX3_ID
        See Also:
        Constant Field Values
      • CFG_SYSSCHEMAS_ID

        private static final java.lang.String CFG_SYSSCHEMAS_ID
        See Also:
        Constant Field Values
      • CFG_SYSSCHEMAS_INDEX1_ID

        private static final java.lang.String CFG_SYSSCHEMAS_INDEX1_ID
        See Also:
        Constant Field Values
      • CFG_SYSSCHEMAS_INDEX2_ID

        private static final java.lang.String CFG_SYSSCHEMAS_INDEX2_ID
        See Also:
        Constant Field Values
      • SYSCONGLOMERATES_CORE_NUM

        private static final int SYSCONGLOMERATES_CORE_NUM
        See Also:
        Constant Field Values
      • SYSFUN_FUNCTIONS

        private static final java.lang.String[][] SYSFUN_FUNCTIONS
        SYSFUN functions. Table of functions that automatically appear in the SYSFUN schema. These functions are resolved to directly if no schema name is given, e.g. SELECT COS(angle) FROM ROOM_WALLS Adding a function here is suitable when the function defintion can have a single return type and fixed parameter types. Functions that need to have a return type based upon the input type(s) are not supported here. Typically those are added into the parser and methods added into the DataValueDescriptor interface. Examples are character based functions whose return type length is based upon the passed in type, e.g. passed a CHAR(10) returns a CHAR(10). This simple table can handle an arbitrary number of arguments and RETURNS NULL ON NULL INPUT. The scheme could be expanded to handle other function options such as other parameters if needed. [0] = FUNCTION name [1] = RETURNS type [2] = Java class [3] = method name and signature [4] = "true" or "false" depending on whether the function is DETERMINSTIC [5] = "true" or "false" depending on whether the function has VARARGS [6..N] = arguments (optional, if not present zero arguments is assumed)
      • SYSFUN_DETERMINISTIC_INDEX

        private static final int SYSFUN_DETERMINISTIC_INDEX
        Index into SYSFUN_FUNCTIONS of the DETERMINISTIC indicator. Used to determine whether the system function is DETERMINISTIC
        See Also:
        Constant Field Values
      • SYSFUN_VARARGS_INDEX

        private static final int SYSFUN_VARARGS_INDEX
        Index into SYSFUN_FUNCTIONS of the VARARGS indicator. Used to determine whether the system function has VARARGS
        See Also:
        Constant Field Values
      • SYSFUN_FIRST_PARAMETER_INDEX

        private static final int SYSFUN_FIRST_PARAMETER_INDEX
        The index of the first parameter in entries in the SYSFUN_FUNCTIONS table. Used to determine the parameter count (zero to many).
        See Also:
        Constant Field Values
      • sysfunDescriptors

        private final AliasDescriptor[] sysfunDescriptors
        Runtime definition of the functions from SYSFUN_FUNCTIONS. Populated dynamically as functions are called.
      • declaredGlobalTemporaryTablesSchemaDesc

        private SchemaDescriptor declaredGlobalTemporaryTablesSchemaDesc
      • nonCoreNames

        private static final java.lang.String[] nonCoreNames
      • NUM_NONCORE

        private static final int NUM_NONCORE
      • systemSchemaNames

        private static final java.lang.String[] systemSchemaNames
        List of all "system" schemas

        This list should contain all schema's used by the system and are created when the database is created. Users should not be able to create or drop these schema's and should not be able to create or drop objects in these schema's. This list is used by code that needs to check if a particular schema is a "system" schema.

      • dictionaryVersion

        private DD_Version dictionaryVersion
        Dictionary version of the on-disk database
      • softwareVersion

        private DD_Version softwareVersion
        Dictionary version of the currently running engine
      • authorizationDatabaseOwner

        private java.lang.String authorizationDatabaseOwner
      • usesSqlAuthorization

        private boolean usesSqlAuthorization
      • indexRefresher

        private IndexStatisticsDaemon indexRefresher
        Daemon creating and refreshing index cardinality statistics.
      • startupParameters

        java.util.Properties startupParameters
      • engineType

        int engineType
      • booting

        protected boolean booting
      • sequenceGeneratorCache

        private CacheManager sequenceGeneratorCache
      • tdCacheSize

        int tdCacheSize
      • stmtCacheSize

        int stmtCacheSize
      • seqgenCacheSize

        private int seqgenCacheSize
      • permissionsCacheSize

        int permissionsCacheSize
      • cacheMode

        volatile int cacheMode
      • ddlUsers

        volatile int ddlUsers
      • readersInDDLMode

        volatile int readersInDDLMode
      • sequenceIDs

        private java.util.HashMap<java.lang.String,​java.util.HashMap<java.lang.String,​java.lang.String>> sequenceIDs
      • readOnlyUpgrade

        private boolean readOnlyUpgrade
        True if the database is read only and requires some form of upgrade, that makes the stored prepared statements invalid. With this case the engine is running at a different version to the underlying stored database. This can happen in 5.1 if the database is read only and a different point release (later than 5.1.25?) to the one that created it, has been booted. (Beetle 5170).

        In 5.2 and newer this will be the case if the engine booting the database is newer than the engine that created it.

      • indexStatsUpdateDisabled

        private boolean indexStatsUpdateDisabled
        Tells if the automatic index statistics refresher has been disabled.

        The refresher can be disabled explicitly by the user by setting a property (system wide or database property), or if the daemon encounters an exception it doesn't know how to recover from.

      • indexStatsUpdateLogging

        private boolean indexStatsUpdateLogging
      • indexStatsUpdateTracing

        private java.lang.String indexStatsUpdateTracing
      • systemSQLNameNumber

        private int systemSQLNameNumber
      • calendarForLastSystemSQLName

        private java.util.GregorianCalendar calendarForLastSystemSQLName
      • timeForLastSystemSQLName

        private long timeForLastSystemSQLName
      • sysUtilProceduresWithPublicAccess

        private static final java.lang.String[] sysUtilProceduresWithPublicAccess
        List of procedures in SYSCS_UTIL schema with PUBLIC access
      • sysUtilFunctionsWithPublicAccess

        private static final java.lang.String[] sysUtilFunctionsWithPublicAccess
        List of functions in SYSCS_UTIL schema with PUBLIC access
      • collationTypeOfSystemSchemas

        private int collationTypeOfSystemSchemas
        Collation Type for SYSTEM schemas. In Derby 10.3, this will always be UCS_BASIC
      • collationTypeOfUserSchemas

        private int collationTypeOfUserSchemas
        Collation Type for user schemas. In Derby 10.3, this is either UCS_BASIC or TERRITORY_BASED. The exact value is decided by what has user asked for through JDBC url optional attribute COLLATION. If that atrribute is set to UCS_BASIC, the collation type for user schemas will be UCS_BASIC. If that attribute is set to TERRITORY_BASED, the collation type for user schemas will be TERRITORY_BASED. If the user has not provide COLLATION attribute value in the JDBC url at database create time, then collation type of user schemas will default to UCS_BASIC. Pre-10.3 databases after upgrade to Derby 10.3 will also use UCS_BASIC for collation type of user schemas.
      • DROP

        static final int DROP
        Possible action for visitPermsByGrantee and visitRoleGrants.
        See Also:
        Constant Field Values
      • EXISTS

        static final int EXISTS
        Possible action for visitPermsByGrantee and visitRoleGrants.
        See Also:
        Constant Field Values
      • spsSet

        private java.lang.String spsSet
      • colPrivTypeMap

        private static final java.lang.String[] colPrivTypeMap
      • colPrivTypeMapForGrant

        private static final java.lang.String[] colPrivTypeMapForGrant
      • DIAG_VTI_TABLE_CLASSES

        private java.lang.String[][] DIAG_VTI_TABLE_CLASSES
      • DIAG_VTI_TABLE_FUNCTION_CLASSES

        private java.lang.String[][] DIAG_VTI_TABLE_FUNCTION_CLASSES
    • Constructor Detail

      • DataDictionaryImpl

        public DataDictionaryImpl()
    • Method Detail

      • canSupport

        public boolean canSupport​(java.util.Properties startParams)
        This is the data dictionary implementation for the standard database engine.
        Specified by:
        canSupport in interface ModuleSupportable
        Returns:
        true if this service requested is for a database engine.
      • boot

        public void boot​(boolean create,
                         java.util.Properties startParams)
                  throws StandardException
        Start-up method for this instance of the data dictionary.
        Specified by:
        boot in interface ModuleControl
        Parameters:
        startParams - The start-up parameters
        Throws:
        StandardException - Thrown if the module fails to start
        See Also:
        Monitor, ModuleFactory
      • findDefaultBuiltinAlgorithm

        private java.lang.String findDefaultBuiltinAlgorithm()
        Find the default message digest algorithm to use for BUILTIN authentication on this database.
        Returns:
        the name of the algorithm to use as the default
      • setDependencyManager

        protected void setDependencyManager()
        sets the dependencymanager associated with this dd. subclasses can override this to install their own funky dependency manager.
      • startWriting

        public void startWriting​(LanguageConnectionContext lcc)
                          throws StandardException
        Description copied from interface: DataDictionary
        Inform this DataDictionary that we are about to start writing to it. This means using the various add and drop methods in the DataDictionary. Generally, this is done during execution of DDL.
        Specified by:
        startWriting in interface DataDictionary
        Parameters:
        lcc - The LanguageConnectionContext to use.
        Throws:
        StandardException - Thrown on error
      • setCacheMode

        private void setCacheMode​(int newMode)
      • getAuthorizationDatabaseOwner

        public java.lang.String getAuthorizationDatabaseOwner()
        Get authorizationID of Database Owner
        Specified by:
        getAuthorizationDatabaseOwner in interface DataDictionary
        Returns:
        authorizationID
      • getCollationTypeOfUserSchemas

        public int getCollationTypeOfUserSchemas()
        Description copied from interface: DataDictionary
        Return the collation type for user schemas. In Derby 10.3, this is either UCS_BASIC or TERRITORY_BASED. The exact value is decided by what has user asked for through JDBC url optional attribute COLLATION. If that atrribute is set to UCS_BASIC, the collation type for user schemas will be UCS_BASIC. If that attribute is set to TERRITORY_BASED, the collation type for user schemas will be TERRITORY_BASED. If the user has not provided COLLATION attribute value in the JDBC url at database create time, then collation type of user schemas will default to UCS_BASIC. Pre-10.3 databases after upgrade to Derby 10.3 will also use UCS_BASIC for collation type of user schemas.
        Specified by:
        getCollationTypeOfUserSchemas in interface DataDictionary
        Returns:
        the collation type for user schemas
        See Also:
        DataDictionary.getCollationTypeOfUserSchemas()
      • getBuiltinSystemSchemas

        private void getBuiltinSystemSchemas()
        Set up the builtin schema descriptors for system schemas.
      • generateRandomSalt

        private byte[] generateRandomSalt​(java.util.Dictionary props)
        Generate an array of random bytes to use as salt when hashing credentials.
        Parameters:
        props - database properties that possibly specify the desired length of the salt
        Returns:
        random bytes
      • getIntProperty

        private int getIntProperty​(java.util.Dictionary props,
                                   java.lang.String key,
                                   int defaultValue,
                                   int minValue,
                                   int maxValue)
        Get the value of an integer property.
        Parameters:
        props - database properties
        key - the key of the property
        defaultValue - which value to return if the property is not set, or if the property value is not in the valid range
        minValue - lowest property value to accept
        maxValue - highest property value to accept
        Returns:
        the value of the property
      • getSystemSchemaDescriptor

        public SchemaDescriptor getSystemSchemaDescriptor()
                                                   throws StandardException
        Get the descriptor for the system schema. Schema descriptors include authorization ids and schema ids. SQL92 allows a schema to specify a default character set - we will not support this.
        Specified by:
        getSystemSchemaDescriptor in interface DataDictionary
        Returns:
        The descriptor for the schema.
        Throws:
        StandardException - Thrown on failure
      • getSystemUtilSchemaDescriptor

        public SchemaDescriptor getSystemUtilSchemaDescriptor()
                                                       throws StandardException
        Get the descriptor for the SYSCS_UTIL system schema. Schema descriptors include authorization ids and schema ids. SQL92 allows a schema to specify a default character set - we will not support this.
        Returns:
        The descriptor for the schema.
        Throws:
        StandardException - Thrown on failure
      • getSysIBMSchemaDescriptor

        public SchemaDescriptor getSysIBMSchemaDescriptor()
                                                   throws StandardException
        Get the descriptor for the SYSIBM schema. Schema descriptors include authorization ids and schema ids. SQL92 allows a schema to specify a default character set - we will not support this.
        Specified by:
        getSysIBMSchemaDescriptor in interface DataDictionary
        Returns:
        The descriptor for the schema.
        Throws:
        StandardException - Thrown on failure
      • getSchemaDescriptor

        public SchemaDescriptor getSchemaDescriptor​(java.lang.String schemaName,
                                                    TransactionController tc,
                                                    boolean raiseError)
                                             throws StandardException
        Get the descriptor for the named schema. Schema descriptors include authorization ids and schema ids. SQL92 allows a schema to specify a default character set - we will not support this. Will check default schema for a match before scanning a system table.
        Specified by:
        getSchemaDescriptor in interface DataDictionary
        Parameters:
        schemaName - The name of the schema we're interested in. Must not be null.
        tc - TransactionController
        raiseError - whether an exception should be thrown if the schema does not exist.
        Returns:
        The descriptor for the schema. Can be null (not found) if raiseError is false.
        Throws:
        StandardException - Thrown on error
      • locateSchemaRow

        private SchemaDescriptor locateSchemaRow​(UUID schemaId,
                                                 TransactionController tc)
                                          throws StandardException
        Get the target schema by searching for a matching row in SYSSCHEMAS by schemaId. Read only scan.
        Parameters:
        schemaId - The id of the schema we're interested in. If non-null, overrides schemaName
        tc - TransactionController. If null, one is gotten off of the language connection context.
        Returns:
        The row for the schema
        Throws:
        StandardException - Thrown on error
      • locateSchemaRow

        private SchemaDescriptor locateSchemaRow​(UUID schemaId,
                                                 int isolationLevel,
                                                 TransactionController tc)
                                          throws StandardException
        Get the target schema by searching for a matching row in SYSSCHEMAS by schemaId. Read only scan.
        Parameters:
        schemaId - The id of the schema we're interested in. If non-null, overrides schemaName
        isolationLevel - Use this explicit isolation level. Only ISOLATION_REPEATABLE_READ (normal usage) or ISOLATION_READ_UNCOMMITTED (corner cases) supported for now.
        tc - TransactionController. If null, one is gotten off of the language connection context.
        Returns:
        The row for the schema
        Throws:
        StandardException - Thrown on error
      • locateSchemaRow

        private SchemaDescriptor locateSchemaRow​(java.lang.String schemaName,
                                                 TransactionController tc)
                                          throws StandardException
        Get the target schema by searching for a matching row in SYSSCHEMAS by schema name. Read only scan.
        Parameters:
        schemaName - The name of the schema we're interested in. If schemaId is null, used to qual.
        tc - TransactionController. If null, one is gotten off of the language connection context.
        Returns:
        The row for the schema
        Throws:
        StandardException - Thrown on error
      • getSchemaDescriptor

        public SchemaDescriptor getSchemaDescriptor​(UUID schemaId,
                                                    int isolationLevel,
                                                    TransactionController tc)
                                             throws StandardException
        Get the SchemaDescriptor for the given schema identifier.
        Specified by:
        getSchemaDescriptor in interface DataDictionary
        Parameters:
        schemaId - the uuid of the schema we want a descriptor for
        isolationLevel - use this explicit isolation level. Only ISOLATION_REPEATABLE_READ (normal usage) or ISOLATION_READ_UNCOMMITTED (corner cases) supported for now.
        tc - transaction controller
        Returns:
        The descriptor for the schema, null if no such schema exists.
        Throws:
        StandardException - thrown on error
      • existsSchemaOwnedBy

        public boolean existsSchemaOwnedBy​(java.lang.String authid,
                                           TransactionController tc)
                                    throws StandardException
        Return true of there exists a schema whose authorizationId equals authid, i.e. SYS.SYSSCHEMAS contains a row whose column (AUTHORIZATIONID) equals authid.
        Specified by:
        existsSchemaOwnedBy in interface DataDictionary
        Parameters:
        authid - authorizationId
        tc - TransactionController
        Returns:
        true iff there is a matching schema
        Throws:
        StandardException
      • getTableDescriptor

        public TableDescriptor getTableDescriptor​(java.lang.String tableName,
                                                  SchemaDescriptor schema,
                                                  TransactionController tc)
                                           throws StandardException
        Get the descriptor for the named table within the given schema. If the schema parameter is NULL, it looks for the table in the current (default) schema. Table descriptors include object ids, object types (table, view, etc.)
        Specified by:
        getTableDescriptor in interface DataDictionary
        Parameters:
        tableName - The name of the table to get the descriptor for
        schema - The descriptor for the schema the table lives in. If null, use the system schema.
        tc - Transaction context.
        Returns:
        The descriptor for the table, null if table does not exist.
        Throws:
        StandardException - Thrown on failure
      • getTableDescriptorIndex1Scan

        private TableDescriptor getTableDescriptorIndex1Scan​(java.lang.String tableName,
                                                             java.lang.String schemaUUID)
                                                      throws StandardException
        Scan systables_index1 (tablename, schemaid) for a match.
        Returns:
        TableDescriptor The matching descriptor, if any.
        Throws:
        StandardException - Thrown on failure
      • getUncachedTableDescriptor

        TableDescriptor getUncachedTableDescriptor​(TableKey tableKey)
                                            throws StandardException
        This method can get called from the DataDictionary cache.
        Parameters:
        tableKey - The TableKey of the table
        Returns:
        The descriptor for the table, null if the table does not exist.
        Throws:
        StandardException - Thrown on failure
      • getTableDescriptor

        public TableDescriptor getTableDescriptor​(UUID tableID)
                                           throws StandardException
        Get the descriptor for the table with the given UUID. NOTE: I'm assuming that the object store will define an UUID for persistent objects. I'm also assuming that UUIDs are unique across schemas, and that the object store will be able to do efficient lookups across schemas (i.e. that no schema descriptor parameter is needed).
        Specified by:
        getTableDescriptor in interface DataDictionary
        Parameters:
        tableID - The UUID of the table to get the descriptor for
        Returns:
        The descriptor for the table, null if the table does not exist.
        Throws:
        StandardException - Thrown on failure
      • getUncachedTableDescriptor

        protected TableDescriptor getUncachedTableDescriptor​(UUID tableID)
                                                      throws StandardException
        This method can get called from the DataDictionary cache.
        Parameters:
        tableID - The UUID of the table to get the descriptor for
        Returns:
        The descriptor for the table, null if the table does not exist.
        Throws:
        StandardException - Thrown on failure
      • getTableDescriptorIndex2Scan

        private TableDescriptor getTableDescriptorIndex2Scan​(java.lang.String tableUUID)
                                                      throws StandardException
        Scan systables_index2 (tableid) for a match.
        Returns:
        TableDescriptor The matching descriptor, if any.
        Throws:
        StandardException - Thrown on failure
      • finishTableDescriptor

        private TableDescriptor finishTableDescriptor​(TableDescriptor td)
                                               throws StandardException
        Finish filling in the TableDescriptor. (Build the various lists that hang off the TD.)
        Parameters:
        td - The TableDescriptor.
        Returns:
        The completed TableDescriptor.
        Throws:
        StandardException - Thrown on failure
      • isSchemaEmpty

        public boolean isSchemaEmpty​(SchemaDescriptor sd)
                              throws StandardException
        Indicate whether there is anything in the particular schema. Checks for tables in the the schema, on the assumption that there cannot be any other objects in a schema w/o a table.
        Specified by:
        isSchemaEmpty in interface DataDictionary
        Parameters:
        sd - descriptor
        Returns:
        true/false
        Throws:
        StandardException - on error
      • isSchemaReferenced

        protected boolean isSchemaReferenced​(TransactionController tc,
                                             TabInfoImpl ti,
                                             int indexId,
                                             int indexCol,
                                             DataValueDescriptor schemaIdOrderable)
                                      throws StandardException
        Is the schema id referenced by the system table in question? Currently assumes that the schema id is in an index. NOTE: could be generalized a bit, and possibly used elsewhere...
        Parameters:
        tc - transaction controller
        ti - table info for the system table
        indexId - index id
        indexCol - 1 based index column
        schemaIdOrderable - the schemaid in a char orderable
        Returns:
        true if there is a reference to this schema
        Throws:
        StandardException - on error
      • upgradeCLOBGETSUBSTRING_10_6

        void upgradeCLOBGETSUBSTRING_10_6​(TransactionController tc)
                                   throws StandardException
        10.6 upgrade logic to update the return type of SYSIBM.CLOBGETSUBSTRING. The length of the return type was changed in 10.5 but old versions of the metadata were not upgraded at that time. See DERBY-4214.
        Throws:
        StandardException
      • upgradeSYSROUTINEPERMS_10_6

        void upgradeSYSROUTINEPERMS_10_6​(TransactionController tc)
                                  throws StandardException
        10.6 upgrade logic to update the permissions granted to SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE. If a 10.0 database was upgraded to 10.2, 10.3, or 10.4, then there will be an extra permissions tuple in SYSROUTINEPERMS--that tuple will have a null grantor field. We must delete this tuple. See DERBY-4215.
        Throws:
        StandardException
      • getColumnDescriptorsScan

        private void getColumnDescriptorsScan​(TableDescriptor td)
                                       throws StandardException
        Populate the ColumnDescriptorList for the specified TableDescriptor. MT synchronization: it is assumed that the caller has synchronized on the CDL in the given TD.
        Parameters:
        td - The TableDescriptor.
        Throws:
        StandardException - Thrown on failure
      • getColumnDescriptorsScan

        private void getColumnDescriptorsScan​(UUID uuid,
                                              ColumnDescriptorList cdl,
                                              TupleDescriptor td)
                                       throws StandardException
        Populate the ColumnDescriptorList for the specified TableDescriptor. MT synchronization: it is assumed that the caller has synchronized on the CDL in the given TD.
        Parameters:
        uuid - The referencing UUID
        cdl - The column descriptor list
        td - The parent tuple descriptor
        Throws:
        StandardException - Thrown on failure
      • dropColumnDescriptor

        public void dropColumnDescriptor​(UUID tableID,
                                         java.lang.String columnName,
                                         TransactionController tc)
                                  throws StandardException
        Given a column name and a table ID, drops the column descriptor from the table.
        Specified by:
        dropColumnDescriptor in interface DataDictionary
        Parameters:
        tableID - The UUID of the table to drop the column from
        columnName - The name of the column to drop
        tc - TransactionController for the transaction
        Throws:
        StandardException - Thrown on error
      • updateSYSCOLPERMSforAddColumnToUserTable

        public void updateSYSCOLPERMSforAddColumnToUserTable​(UUID tableID,
                                                             TransactionController tc)
                                                      throws StandardException
        Need to update SYSCOLPERMS for a given table because a new column has been added to that table. SYSCOLPERMS has a column called "COLUMNS" which is a bit map for all the columns in a given user table. Since ALTER TABLE .. ADD COLUMN .. has added one more column, we need to expand "COLUMNS" for that new column Currently, this code gets called during execution phase of ALTER TABLE .. ADD COLUMN ..
        Specified by:
        updateSYSCOLPERMSforAddColumnToUserTable in interface DataDictionary
        Parameters:
        tableID - The UUID of the table to which a column has been added
        tc - TransactionController for the transaction
        Throws:
        StandardException - Thrown on error
      • updateSYSCOLPERMSforDropColumn

        public void updateSYSCOLPERMSforDropColumn​(UUID tableID,
                                                   TransactionController tc,
                                                   ColumnDescriptor columnDescriptor)
                                            throws StandardException
        Update SYSCOLPERMS due to dropping a column from a table. Since ALTER TABLE .. DROP COLUMN .. has removed a column from the table, we need to shrink COLUMNS by removing the corresponding bit position, and shifting all the subsequent bits "left" one position.
        Specified by:
        updateSYSCOLPERMSforDropColumn in interface DataDictionary
        Parameters:
        tableID - The UUID of the table from which a col has been dropped
        tc - TransactionController for the transaction
        columnDescriptor - Information about the dropped column
        Throws:
        StandardException - Thrown on error
      • rewriteSYSCOLPERMSforAlterTable

        private void rewriteSYSCOLPERMSforAlterTable​(UUID tableID,
                                                     TransactionController tc,
                                                     ColumnDescriptor columnDescriptor)
                                              throws StandardException
        Workhorse for ALTER TABLE-driven mods to SYSCOLPERMS This method finds all the SYSCOLPERMS rows for this table. Then it iterates through each row, either adding a new column to the end of the table, or dropping a column from the table, as appropriate. It updates each SYSCOLPERMS row to store the new COLUMNS value.
        Parameters:
        tableID - The UUID of the table being altered
        tc - TransactionController for the transaction
        columnDescriptor - Dropped column info, or null if adding
        Throws:
        StandardException - Thrown on error
      • existsRoleGrantByGrantee

        private boolean existsRoleGrantByGrantee​(java.lang.String grantee,
                                                 TransactionController tc)
                                          throws StandardException
        Return true if there exists a role grant to authorization identifier.
        Parameters:
        grantee - authorization identifier
        tc - Transaction Controller
        Returns:
        true if there exists such a grant
        Throws:
        StandardException - Thrown on failure
      • visitRoleGrants

        private boolean visitRoleGrants​(TabInfoImpl ti,
                                        SYSROLESRowFactory rf,
                                        int columnNo,
                                        java.lang.String authId,
                                        TransactionController tc,
                                        int action)
                                 throws StandardException
        Scan the {roleid, grantee, grantor} index on SYSROLES, locate rows containing authId in column columnNo. The action argument can be either EXISTS or DROP (to check for existence, or to drop that row). If the scan proves too slow, we should add more indexes. only.
        Parameters:
        ti - TabInfoImpl for SYSROLES.
        rf - row factory for SYSROLES
        columnNo - the column number to match authId against
        tc - transaction controller
        action - drop matching rows (DROP), or return true if there is a matching row (EXISTS)
        Returns:
        action=EXISTS: return true if there is a matching row else return false.
        Throws:
        StandardException
      • getRoleGrantGraph

        java.util.HashMap<java.lang.String,​java.util.List<RoleGrantDescriptor>> getRoleGrantGraph​(TransactionController tc,
                                                                                                        boolean inverse)
                                                                                                 throws StandardException
        Return an in-memory representation of the role grant graph (sans grant of roles to users, only role-role relation.
        Parameters:
        tc - Transaction Controller
        inverse - make graph on inverse grant relation
        Returns:
        hash map representing role grant graph.
        • Key: rolename,
        • Value: List representing a grant of that rolename to another role (not user).
        FIXME: Need to cache graph and invalidate when role graph is modified. Currently, we always read from SYSROLES.
        Throws:
        StandardException
      • dropPermsByGrantee

        private void dropPermsByGrantee​(java.lang.String authId,
                                        TransactionController tc,
                                        int catalog,
                                        int indexNo,
                                        int granteeColnoInIndex)
                                 throws StandardException
        Presently only used when dropping roles - user dropping is not under Derby control (well, built-in users are if properties are stored in database), any permissions granted to users remain in place even if the user is no more.
        Throws:
        StandardException
      • existsPermByGrantee

        private boolean existsPermByGrantee​(java.lang.String authId,
                                            TransactionController tc,
                                            int catalog,
                                            int indexNo,
                                            int granteeColnoInIndex)
                                     throws StandardException
        Return true if there exists a permission grant descriptor to this authorization id.
        Throws:
        StandardException
      • visitPermsByGrantee

        private boolean visitPermsByGrantee​(java.lang.String authId,
                                            TransactionController tc,
                                            int catalog,
                                            int indexNo,
                                            int granteeColnoInIndex,
                                            int action)
                                     throws StandardException
        Scan indexNo index on a permission table catalog, looking for match(es) for the grantee column (given by granteeColnoInIndex for the catalog in question). The action argument can be either EXISTS or DROP (to check for existence, or to drop that row). There is no index on grantee column only on on any of the permissions tables, so we use the index which contain grantee and scan that, setting up a scan qualifier to match the grantee, then fetch the base row. If this proves too slow, we should add an index on grantee only.
        Parameters:
        authId - grantee to match against
        tc - transaction controller
        catalog - the underlying permission table to visit
        indexNo - the number of the index by which to access the catalog
        granteeColnoInIndex - the column number to match authId against
        action - drop matching rows (DROP), or return true if there is a matching row (EXISTS)
        Returns:
        action=EXISTS: return true if there is a matching row else return false.
        Throws:
        StandardException
      • dropColumnDescriptorCore

        private void dropColumnDescriptorCore​(TransactionController tc,
                                              ExecIndexRow keyRow)
                                       throws StandardException
        Delete the appropriate rows from syscolumns when dropping 1 or more columns.
        Parameters:
        tc - The TransactionController
        keyRow - Start/stop position.
        Throws:
        StandardException - Thrown on failure
      • updateColumnDescriptor

        private void updateColumnDescriptor​(ColumnDescriptor cd,
                                            UUID formerUUID,
                                            java.lang.String formerName,
                                            int[] colsToSet,
                                            TransactionController tc)
                                     throws StandardException
        Update the column descriptor in question. Updates every row in the base conglomerate.
        Parameters:
        cd - The ColumnDescriptor
        formerUUID - The UUID for this column in SYSCOLUMNS, may differ from what is in cd if this is the column that is being set.
        formerName - The name for this column in SYSCOLUMNS may differ from what is in cd if this is the column that is being set.
        colsToSet - Array of ints of columns to be modified, 1 based. May be null (all cols).
        tc - The TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • getViewDescriptorScan

        private ViewDescriptor getViewDescriptorScan​(TableDescriptor tdi)
                                              throws StandardException
        Get the information for the view from sys.sysviews.
        Parameters:
        tdi - The TableDescriptor for the view.
        Returns:
        ViewDescriptor The ViewDescriptor for the view.
        Throws:
        StandardException - Thrown on error
      • getFileInfoDescriptorIndex1Scan

        private FileInfoDescriptor getFileInfoDescriptorIndex1Scan​(UUID schemaId,
                                                                   java.lang.String name)
                                                            throws StandardException
        Scan sysfiles_index1 (schemaid,name) for a match.
        Returns:
        The matching descriptor or null.
        Throws:
        StandardException - Thrown on failure
      • spsCacheEntryAdded

        void spsCacheEntryAdded​(SPSDescriptor spsd)
        Add an entry to the hashtables for lookup from the cache.
      • spsCacheEntryRemoved

        void spsCacheEntryRemoved​(SPSDescriptor spsd)
      • getUncachedSPSDescriptor

        SPSDescriptor getUncachedSPSDescriptor​(TableKey stmtKey)
                                        throws StandardException
        This method can get called from the DataDictionary cache.
        Parameters:
        stmtKey - The TableKey of the sps
        Returns:
        The descriptor for the sps, null if the sps does not exist.
        Throws:
        StandardException - Thrown on failure
      • getUncachedSPSDescriptor

        protected SPSDescriptor getUncachedSPSDescriptor​(UUID stmtId)
                                                  throws StandardException
        This method can get called from the DataDictionary cache.
        Parameters:
        stmtId - The UUID of the stmt to get the descriptor for
        Returns:
        The descriptor for the stmt, null if the table does not exist.
        Throws:
        StandardException - Thrown on failure
      • getSPSDescriptorIndex2Scan

        private SPSDescriptor getSPSDescriptorIndex2Scan​(java.lang.String stmtUUID)
                                                  throws StandardException
        Scan sysstatements_index2 (stmtid) for a match. Note that we do not do a lookup of parameter info.
        Returns:
        SPSDescriptor The matching descriptor, if any.
        Throws:
        StandardException - Thrown on failure
      • getSPSDescriptor

        public SPSDescriptor getSPSDescriptor​(java.lang.String stmtName,
                                              SchemaDescriptor sd)
                                       throws StandardException
        Get a SPSDescriptor given its name. Currently no cacheing. With caching we need to be very careful about invalidation. No caching means invalidations block on existing SPSD instances (since they were read in
        Specified by:
        getSPSDescriptor in interface DataDictionary
        Parameters:
        stmtName - the statement name
        sd - The SchemaDescriptor
        Returns:
        The SPSDescriptor for the constraint.
        Throws:
        StandardException - Thrown on failure
      • getSPSDescriptorIndex1Scan

        private SPSDescriptor getSPSDescriptorIndex1Scan​(java.lang.String stmtName,
                                                         java.lang.String schemaUUID)
                                                  throws StandardException
        Scan sysschemas_index1 (stmtname, schemaid) for a match.
        Returns:
        SPSDescriptor The matching descriptor, if any.
        Throws:
        StandardException - Thrown on failure
      • clearSPSPlans

        void clearSPSPlans()
                    throws StandardException
        Mark all SPS plans in the data dictionary invalid. This does not invalidate cached plans. This function is for use by the boot-up code.
        Throws:
        StandardException - Thrown on error
      • getAllSPSDescriptors

        public java.util.List<SPSDescriptor> getAllSPSDescriptors()
                                                           throws StandardException
        Get every statement in this database. Return the SPSDescriptors in an list. The returned descriptors don't contain the compiled statement, so it it safe to call this method during upgrade when it isn't known if the saved statement can still be deserialized with the new version.
        Specified by:
        getAllSPSDescriptors in interface DataDictionary
        Returns:
        the list of descriptors
        Throws:
        StandardException - Thrown on failure
      • getAllConstraintDescriptors

        private ConstraintDescriptorList getAllConstraintDescriptors()
                                                              throws StandardException
        Get every constraint in this database. Note that this list of ConstraintDescriptors is not going to be the same objects that are typically cached off of the table descriptors, so this will most likely instantiate some duplicate objects.
        Returns:
        the list of descriptors
        Throws:
        StandardException - Thrown on failure
      • examineTriggerNodeAndCols

        public int[] examineTriggerNodeAndCols​(Visitable actionStmt,
                                               java.lang.String oldReferencingName,
                                               java.lang.String newReferencingName,
                                               java.lang.String triggerDefinition,
                                               int[] referencedCols,
                                               int[] referencedColsInTriggerAction,
                                               int actionOffset,
                                               TableDescriptor triggerTableDescriptor,
                                               int triggerEventMask,
                                               boolean createTriggerTime,
                                               java.util.List<int[]> replacements)
                                        throws StandardException
        Get the trigger action string associated with the trigger after the references to old/new transition tables/variables in trigger action sql provided by CREATE TRIGGER have been transformed eg DELETE FROM t WHERE c = old.c turns into DELETE FROM t WHERE c = org.apache.derby.iapi.db.Factory:: getTriggerExecutionContext().getOldRow(). getInt(columnNumberFor'C'inRuntimeResultset) or DELETE FROM t WHERE c in (SELECT c FROM OLD) turns into DELETE FROM t WHERE c in (SELECT c FROM new TriggerOldTransitionTable OLD)
        Specified by:
        examineTriggerNodeAndCols in interface DataDictionary
        Parameters:
        actionStmt - This is needed to get access to the various nodes generated by the Parser for the trigger action sql. These nodes will be used to find REFERENCEs column nodes.
        oldReferencingName - The name specified by the user for REFERENCEs to old row columns
        newReferencingName - The name specified by the user for REFERENCEs to new row columns
        triggerDefinition - The original trigger action text provided by the user during CREATE TRIGGER time.
        referencedCols - Trigger is defined on these columns (will be null in case of INSERT AND DELETE Triggers. Can also be null for DELETE Triggers if UPDATE trigger is not defined on specific column(s))
        referencedColsInTriggerAction - what columns does the trigger action reference through old/new transition variables (may be null)
        actionOffset - offset of start of action clause
        triggerTableDescriptor - Table descriptor for trigger table
        triggerEventMask - TriggerDescriptor.TRIGGER_EVENT_XXX
        createTriggerTime - True if here for CREATE TRIGGER, false if here because an invalidated row level trigger with REFERENCEd columns has been fired and hence trigger action sql associated with SPSDescriptor may be invalid too.
        Returns:
        Transformed trigger action sql
        Throws:
        StandardException
      • getTriggerActionString

        public java.lang.String getTriggerActionString​(Visitable actionStmt,
                                                       java.lang.String oldReferencingName,
                                                       java.lang.String newReferencingName,
                                                       java.lang.String triggerDefinition,
                                                       int[] referencedCols,
                                                       int[] referencedColsInTriggerAction,
                                                       int actionOffset,
                                                       TableDescriptor triggerTableDescriptor,
                                                       int triggerEventMask,
                                                       boolean createTriggerTime,
                                                       java.util.List<int[]> replacements,
                                                       int[] cols)
                                                throws StandardException
        Description copied from interface: DataDictionary
        This method does the job of transforming the trigger action plan text as shown below. DELETE FROM t WHERE c = old.c turns into DELETE FROM t WHERE c = org.apache.derby.iapi.db.Factory:: getTriggerExecutionContext().getOldRow(). getInt(columnNumberFor'C'inRuntimeResultset); In addition to that, for CREATE TRIGGER time, it does the job of collecting the column positions of columns referenced in trigger action plan through REFERENCEs clause. This information will get saved in SYSTRIGGERS table by the caller in CREATE TRIGGER case. It gets called either 1)at the trigger creation time for row level triggers or 2)if the trigger got invalidated by some other sql earlier and the current sql needs that trigger to fire. For such a trigger firing case, this method will get called only if it is row level trigger with REFERENCES clause. This work was done as part of DERBY-4874. Before DERBY-4874, once the stored prepared statement for trigger action plan was generated, it was never updated ever again. But, one case where the trigger action plan needs to be regenerated is say when the column length is changed for a column which is REFERENCEd as old or new column value. eg of such a case would be say the Alter table has changed the length of a varchar column from varchar(30) to varchar(64) but the stored prepared statement associated with the trigger action plan continued to use varchar(30). To fix varchar(30) in stored prepared statement for trigger action sql to varchar(64), we need to regenerate the trigger action sql. This new trigger action sql will then get updated into SYSSTATEMENTS table. If we are here for case 1) above, then we will collect all column references in trigger action through new/old transition variables. Information about them will be saved in SYSTRIGGERS table DERBY-1482 (if we are dealing with pre-10.7 db, then we will not put any information about trigger action columns in the system table to ensure backward compatibility). This information along with the trigger columns will decide what columns from the trigger table will be fetched into memory during trigger execution. If we are here for case 2) above, then all the information about column references in trigger action has already been collected during CREATE TRIGGER time and hence we can use that available information about column positions to do the transformation of OLD/NEW transient references. More information on case 1) above. DERBY-1482 One of the work done by this method for row level triggers is to find the columns which are referenced in the trigger action through the REFERENCES clause ie thro old/new transition variables. This information will be saved in SYSTRIGGERS so it can be retrieved during the trigger execution time. The purpose of this is to recognize what columns from the trigger table should be read in during trigger execution. Before these code changes, during trigger execution, Derby was opting to read all the columns from the trigger table even if they were not all referenced during the trigger execution. This caused Derby to run into OOM at times when it could really be avoided. We go through the trigger action text and collect the column positions of all the REFERENCEd columns through new/old transition variables. We keep that information in SYSTRIGGERS. At runtime, when the trigger is fired, we will look at this information along with trigger columns from the trigger definition and only fetch those columns into memory rather than all the columns from the trigger table. This is especially useful when the table has LOB columns and those columns are not referenced in the trigger action and are not recognized as trigger columns. For such cases, we can avoid reading large values of LOB columns into memory and thus avoiding possibly running into OOM errors. If there are no trigger columns defined on the trigger, we will read all the columns from the trigger table when the trigger fires because no specific columns were identified as trigger column by the user. The other case where we will opt to read all the columns are when trigger columns and REFERENCING clause is identified for the trigger but there is no trigger action column information in SYSTRIGGERS. This can happen for triggers created prior to 10.7 release and later that database got hard/soft-upgraded to 10.7 or higher release.
        Specified by:
        getTriggerActionString in interface DataDictionary
        Parameters:
        actionStmt - This is needed to get access to the various nodes generated by the Parser for the trigger action sql. These nodes will be used to find REFERENCEs column nodes.
        oldReferencingName - The name specified by the user for REFERENCEs to old row columns
        newReferencingName - The name specified by the user for REFERENCEs to new row columns
        triggerDefinition - The original trigger action text provided by the user during CREATE TRIGGER time.
        referencedCols - Trigger is defined on these columns (will be null in case of INSERT AND DELETE Triggers. Can also be null for DELETE Triggers if UPDATE trigger is not defined on specific column(s))
        referencedColsInTriggerAction - what columns does the trigger action reference through old/new transition variables (may be null)
        actionOffset - offset of start of action clause
        triggerTableDescriptor - Table descriptor for trigger table
        triggerEventMask - TriggerDescriptor.TRIGGER_EVENT_XXX
        createTriggerTime - True if here for CREATE TRIGGER, false if here because an invalidated row level trigger with REFERENCEd columns has been fired and hence trigger action sql associated with SPSDescriptor may be invalid too.
        replacements - a list that will be populated with objects that describe how triggerDefinition has been transformed into the returned SQL text. Each element in the list will contain four integers. The first two describe the begin and end offset of the replaced text in the triggerDefinition. The last two describe the begin and end offset of the replacement text in the returned string. The begin offsets are inclusive, whereas the end offsets are exclusive. The list can be null if the caller does not care about this information.
        Returns:
        Transformed trigger action sql
        Throws:
        StandardException
      • getTransitionVariables

        private static java.util.SortedSet<ColumnReference> getTransitionVariables​(Visitable node,
                                                                                   java.lang.String oldReferencingName,
                                                                                   java.lang.String newReferencingName)
                                                                            throws StandardException
        Get all columns that reference transition variables in triggers. The columns should be returned in the same order as in the SQL text.
        Parameters:
        node - the node in which to look for transition variables
        oldReferencingName - the name of the old transition variable
        newReferencingName - the name of the new transition variable
        Returns:
        all references to transition variables
        Throws:
        StandardException
      • isTransitionVariable

        private static boolean isTransitionVariable​(TableName tableName,
                                                    java.lang.String oldReferencingName,
                                                    java.lang.String newReferencingName)
        Check if a table name is actually a transition variable.
        Parameters:
        tableName - the table name to check
        oldReferencingName - the name of the old transition variable
        newReferencingName - the name of the new transition variable
        Returns:
        true if the table name is a transition variable, false otherwise
      • justTheRequiredColumns

        private int[] justTheRequiredColumns​(int[] columnsArrary,
                                             TableDescriptor triggerTableDescriptor)
      • checkInvalidTriggerReference

        private void checkInvalidTriggerReference​(java.lang.String tableName,
                                                  java.lang.String oldReferencingName,
                                                  java.lang.String newReferencingName,
                                                  int triggerEventMask)
                                           throws StandardException
        Throws:
        StandardException
      • genColumnReferenceSQL

        private java.lang.String genColumnReferenceSQL​(TableDescriptor td,
                                                       java.lang.String colName,
                                                       java.lang.String tabName,
                                                       boolean isOldTable,
                                                       int colPositionInRuntimeResultSet)
                                                throws StandardException
        Throws:
        StandardException
      • getTriggerDescriptorsScan

        private void getTriggerDescriptorsScan​(TableDescriptor td,
                                               boolean forUpdate)
                                        throws StandardException
        Populate the TriggerDescriptorList for the specified TableDescriptor. MT synchronization: it is assumed that the caller has synchronized on the CDL in the given TD.
        Parameters:
        td - The TableDescriptor.
        forUpdate - Whether or not to open scan for update
        Throws:
        StandardException - Thrown on failure
      • updateTriggerDescriptor

        public void updateTriggerDescriptor​(TriggerDescriptor triggerd,
                                            UUID formerUUID,
                                            int[] colsToSet,
                                            TransactionController tc)
                                     throws StandardException
        Update the trigger descriptor in question. Updates every row in the base conglomerate that matches the uuid.
        Specified by:
        updateTriggerDescriptor in interface DataDictionary
        Parameters:
        triggerd - The Trigger descriptor
        formerUUID - The UUID for this column in SYSTRIGGERS, may differ from what is in triggerd if this is the column that is being set.
        colsToSet - Array of ints of columns to be modified, 1 based. May be null (all cols).
        tc - The TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • getConstraintDescriptor

        public ConstraintDescriptor getConstraintDescriptor​(java.lang.String constraintName,
                                                            UUID schemaID)
                                                     throws StandardException
        Get a ConstraintDescriptor given its name and schema ID. Please use getConstraintDescriptorByName() if you have the constraint's table descriptor, it is much faster.
        Specified by:
        getConstraintDescriptor in interface DataDictionary
        Parameters:
        constraintName - Constraint name.
        schemaID - The schema UUID
        Returns:
        The ConstraintDescriptor for the constraint.
        Throws:
        StandardException - Thrown on failure
      • getStatisticsDescriptors

        public java.util.List<StatisticsDescriptor> getStatisticsDescriptors​(TableDescriptor td)
                                                                      throws StandardException
        Returns all the statistics descriptors for the given table.

        NOTE: As opposed to most other data dictionary lookups, this operation is performed with isolation level READ_UNCOMMITTED. The reason is to avoid deadlocks with inserts into the statistics system table.

        Specified by:
        getStatisticsDescriptors in interface DataDictionary
        Parameters:
        td - TableDescriptor for which I need statistics
        Returns:
        A list of tuple descriptors, possibly empty.
        Throws:
        StandardException
      • getConstraintDescriptors

        public ConstraintDescriptorList getConstraintDescriptors​(TableDescriptor td)
                                                          throws StandardException
        Load up the constraint descriptor list for this table descriptor and return it. If the descriptor list is already loaded up, it is retuned without further ado. If no table descriptor is passed in, then all constraint descriptors are retrieved. Note that in this case, the constraint descriptor objects may be duplicates of constraint descriptors that are hung off of the table descriptor cache.
        Specified by:
        getConstraintDescriptors in interface DataDictionary
        Parameters:
        td - The table descriptor. If null, all constraint descriptors are returned.
        Returns:
        The ConstraintDescriptorList for the table
        Throws:
        StandardException - Thrown on failure
      • getActiveConstraintDescriptors

        public ConstraintDescriptorList getActiveConstraintDescriptors​(ConstraintDescriptorList cdl)
                                                                throws StandardException
        Convert a constraint descriptor list into a list of active constraints, that is, constraints which must be enforced. For the Core product, these are just the constraints on the original list. However, during REFRESH we may have deferred some constraints until statement end. This method returns the corresponding list of constraints which AREN'T deferred.
        Specified by:
        getActiveConstraintDescriptors in interface DataDictionary
        Parameters:
        cdl - The constraint descriptor list to wrap with an Active constraint descriptor list.
        Returns:
        The corresponding Active ConstraintDescriptorList
        Throws:
        StandardException - Thrown on failure
      • activeConstraint

        public boolean activeConstraint​(ConstraintDescriptor constraint)
                                 throws StandardException
        Reports whether an individual constraint must be enforced. For the Core product, this routine always returns true. However, during REFRESH we may have deferred some constraints until statement end. This method returns false if the constraint deferred
        Specified by:
        activeConstraint in interface DataDictionary
        Parameters:
        constraint - the constraint to check
        Returns:
        The corresponding Active ConstraintDescriptorList
        Throws:
        StandardException - Thrown on failure
      • getConstraintDescriptorByName

        public ConstraintDescriptor getConstraintDescriptorByName​(TableDescriptor td,
                                                                  SchemaDescriptor sd,
                                                                  java.lang.String constraintName,
                                                                  boolean forUpdate)
                                                           throws StandardException
        Get the constraint descriptor given a TableDescriptor and the constraint name.
        Specified by:
        getConstraintDescriptorByName in interface DataDictionary
        Parameters:
        td - The table descriptor.
        sd - The schema descriptor for the constraint
        constraintName - The constraint name.
        forUpdate - Whether or not access is for update
        Returns:
        The ConstraintDescriptor for the constraint.
        Throws:
        StandardException - Thrown on failure
      • getConstraintDescriptorsScan

        private void getConstraintDescriptorsScan​(TableDescriptor td,
                                                  boolean forUpdate)
                                           throws StandardException
        Populate the ConstraintDescriptorList for the specified TableDescriptor. MT synchronization: it is assumed that the caller has synchronized on the CDL in the given TD.
        Parameters:
        td - The TableDescriptor.
        forUpdate - Whether or not to open scan for update
        Throws:
        StandardException - Thrown on failure
      • getConstraintDescriptorViaIndex

        protected ConstraintDescriptor getConstraintDescriptorViaIndex​(int indexId,
                                                                       ExecIndexRow keyRow,
                                                                       TabInfoImpl ti,
                                                                       TableDescriptor td,
                                                                       ConstraintDescriptorList dList,
                                                                       boolean forUpdate)
                                                                throws StandardException
        Return a (single or list of) ConstraintDescriptor(s) from SYSCONSTRAINTS where the access is from the index to the heap.
        Parameters:
        indexId - The id of the index (0 to # of indexes on table) to use
        keyRow - The supplied ExecIndexRow for search
        ti - The TabInfoImpl to use
        td - The TableDescriptor, if supplied.
        dList - The list to build, if supplied. If null, then caller expects a single descriptor
        forUpdate - Whether or not to open scan for update
        Returns:
        The last matching descriptor
        Throws:
        StandardException - Thrown on error
      • getConstraintDescriptorViaHeap

        protected TupleDescriptor getConstraintDescriptorViaHeap​(ScanQualifier[][] scanQualifiers,
                                                                 TabInfoImpl ti,
                                                                 TupleDescriptor parentTupleDescriptor,
                                                                 ConstraintDescriptorList list)
                                                          throws StandardException
        Return a (single or list of) catalog row descriptor(s) from SYSCONSTRAINTS through a heap scan
        Parameters:
        scanQualifiers - qualifiers
        ti - The TabInfoImpl to use
        parentTupleDescriptor - The parentDescriptor, if applicable.
        list - The list to build, if supplied. If null, then caller expects a single descriptor
        Returns:
        The last matching descriptor
        Throws:
        StandardException - Thrown on error
      • getConstraintTableDescriptor

        public TableDescriptor getConstraintTableDescriptor​(UUID constraintId)
                                                     throws StandardException
        Return a table descriptor corresponding to the TABLEID field in SYSCONSTRAINTS where CONSTRAINTID matches the constraintId passsed in.
        Specified by:
        getConstraintTableDescriptor in interface DataDictionary
        Parameters:
        constraintId - The id of the constraint
        Returns:
        the corresponding table descriptor
        Throws:
        StandardException - Thrown on error
      • getForeignKeys

        public ConstraintDescriptorList getForeignKeys​(UUID constraintId)
                                                throws StandardException
        Return a list of foreign keys constraints referencing this constraint. Returns both enforced and not enforced foreign keys.
        Specified by:
        getForeignKeys in interface DataDictionary
        Parameters:
        constraintId - The id of the referenced constraint
        Returns:
        list of constraints, empty of there are none
        Throws:
        StandardException - Thrown on error
      • getConstraints

        public java.util.List<UUID> getConstraints​(UUID uuid,
                                                   int indexId,
                                                   int columnNum)
                                            throws StandardException
        Return an List which of the relevant column matching the indexed criteria. If nothing matches, returns an empty List (never returns null).
        Parameters:
        uuid - The id of the constraint
        indexId - The index id in SYS.SYSCONSTRAINTS
        columnNum - The column to retrieve
        Returns:
        a list of UUIDs in an List.
        Throws:
        StandardException - Thrown on error
      • updateConstraintDescriptor

        public void updateConstraintDescriptor​(ConstraintDescriptor cd,
                                               UUID formerUUID,
                                               int[] colsToSet,
                                               TransactionController tc)
                                        throws StandardException
        Update the constraint descriptor in question. Updates every row in the base conglomerate.
        Specified by:
        updateConstraintDescriptor in interface DataDictionary
        Parameters:
        cd - The Constraint descriptor
        formerUUID - The UUID for this column in SYSCONSTRAINTS, may differ from what is in cd if this is the column that is being set.
        colsToSet - Array of integers of columns to be modified, 1 based. May be null (all columns).
        tc - The TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • getSubKeyConstraint

        public SubKeyConstraintDescriptor getSubKeyConstraint​(UUID constraintId,
                                                              int type)
                                                       throws StandardException
        Get a SubKeyConstraintDescriptor from syskeys or sysforeignkeys for the specified constraint id. For primary foreign and and unique key constraints.
        Specified by:
        getSubKeyConstraint in interface DataDictionary
        Parameters:
        constraintId - The UUID for the constraint.
        type - The type of the constraint (e.g. DataDictionary.FOREIGNKEY_CONSTRAINT)
        Returns:
        SubKeyConstraintDescriptor The Sub descriptor for the constraint.
        Throws:
        StandardException - Thrown on failure
      • getSubCheckConstraint

        private SubCheckConstraintDescriptor getSubCheckConstraint​(UUID constraintId)
                                                            throws StandardException
        Get a SubCheckConstraintDescriptor from syschecks for the specified constraint id. (Useful for check constraints.)
        Parameters:
        constraintId - The UUID for the constraint.
        Returns:
        SubCheckConstraintDescriptor The Sub descriptor for the constraint.
        Throws:
        StandardException - Thrown on failure
      • dropSubCheckConstraint

        private void dropSubCheckConstraint​(UUID constraintId,
                                            TransactionController tc)
                                     throws StandardException
        Drop the matching row from syschecks when dropping a check constraint.
        Parameters:
        constraintId - The constraint id.
        tc - The TransactionController
        Throws:
        StandardException - Thrown on failure
      • hashAllConglomerateDescriptorsByNumber

        public java.util.Hashtable<java.lang.Long,​ConglomerateDescriptor> hashAllConglomerateDescriptorsByNumber​(TransactionController tc)
                                                                                                                throws StandardException
        Get all of the ConglomerateDescriptors in the database and hash them by conglomerate number. This is useful as a performance optimization for the locking VTIs. NOTE: This method will scan SYS.SYSCONGLOMERATES at READ UNCOMMITTED.
        Specified by:
        hashAllConglomerateDescriptorsByNumber in interface DataDictionary
        Parameters:
        tc - TransactionController for the transaction
        Returns:
        A Hashtable with all of the ConglomerateDescriptors in the database hashed by conglomerate number.
        Throws:
        StandardException - Thrown on failure
      • hashAllTableDescriptorsByTableId

        public java.util.Hashtable<UUID,​TableDescriptor> hashAllTableDescriptorsByTableId​(TransactionController tc)
                                                                                         throws StandardException
        Get all of the TableDescriptors in the database and hash them by TableId This is useful as a performance optimization for the locking VTIs. NOTE: This method will scan SYS.SYSTABLES and SYS.SYSSCHEMAS at READ UNCOMMITTED.
        Specified by:
        hashAllTableDescriptorsByTableId in interface DataDictionary
        Parameters:
        tc - TransactionController for the transaction
        Returns:
        A Hashtable with all of the Table descriptors in the database hashed by TableId
        Throws:
        StandardException - Thrown on failure
      • getConglomerateDescriptor

        public ConglomerateDescriptor getConglomerateDescriptor​(UUID uuid)
                                                         throws StandardException
        Get a ConglomerateDescriptor given its UUID. If it is an index conglomerate shared by at least another duplicate index, this returns one of the ConglomerateDescriptors for those indexes.
        Specified by:
        getConglomerateDescriptor in interface DataDictionary
        Parameters:
        uuid - The UUID
        Returns:
        A ConglomerateDescriptor for the conglomerate.
        Throws:
        StandardException - Thrown on failure
      • getConglomerateDescriptors

        public ConglomerateDescriptor[] getConglomerateDescriptors​(UUID uuid)
                                                            throws StandardException
        Get an array of ConglomerateDescriptors given the UUID. If it is a heap conglomerate or an index conglomerate not shared by a duplicate index, the size of the return array is 1. If the uuid argument is null, then this method retrieves descriptors for all of the conglomerates in the database.
        Specified by:
        getConglomerateDescriptors in interface DataDictionary
        Parameters:
        uuid - The UUID
        Returns:
        An array of ConglomerateDescriptors for the conglomerate. returns size 0 array if no such conglomerate.
        Throws:
        StandardException - Thrown on failure
      • getConglomerateDescriptor

        public ConglomerateDescriptor getConglomerateDescriptor​(long conglomerateNumber)
                                                         throws StandardException
        Get a ConglomerateDescriptor given its conglomerate number. If it is an index conglomerate shared by at least another duplicate index, this returns one of the ConglomerateDescriptors for those indexes.
        Specified by:
        getConglomerateDescriptor in interface DataDictionary
        Parameters:
        conglomerateNumber - The conglomerate number.
        Returns:
        A ConglomerateDescriptor for the conglomerate. Returns NULL if no such conglomerate.
        Throws:
        StandardException - Thrown on failure
      • getConglomerateDescriptors

        public ConglomerateDescriptor[] getConglomerateDescriptors​(long conglomerateNumber)
                                                            throws StandardException
        Get an array of conglomerate descriptors for the given conglomerate number. If it is a heap conglomerate or an index conglomerate not shared by a duplicate index, the size of the return array is 1.
        Specified by:
        getConglomerateDescriptors in interface DataDictionary
        Parameters:
        conglomerateNumber - The number for the conglomerate we're interested in
        Returns:
        An array of ConglomerateDescriptors that share the requested conglomerate. Returns size 0 array if no such conglomerate.
        Throws:
        StandardException - Thrown on failure
      • getConglomerateDescriptorsScan

        private void getConglomerateDescriptorsScan​(TableDescriptor td)
                                             throws StandardException
        Populate the ConglomerateDescriptorList for the specified TableDescriptor by scanning sysconglomerates. MT synchronization: it is assumed that the caller has synchronized on the CDL in the given TD.
        Parameters:
        td - The TableDescriptor.
        Throws:
        StandardException - Thrown on failure
      • getConglomerateDescriptor

        public ConglomerateDescriptor getConglomerateDescriptor​(java.lang.String indexName,
                                                                SchemaDescriptor sd,
                                                                boolean forUpdate)
                                                         throws StandardException
        Gets a conglomerate descriptor for the named index in the given schema, getting an exclusive row lock on the matching row in sys.sysconglomerates (for DDL concurrency) if requested.
        Specified by:
        getConglomerateDescriptor in interface DataDictionary
        Parameters:
        indexName - The name of the index we're looking for
        sd - The schema descriptor
        forUpdate - Whether or not to get an exclusive row lock on the row in sys.sysconglomerates.
        Returns:
        A ConglomerateDescriptor describing the requested conglomerate. Returns NULL if no such conglomerate.
        Throws:
        StandardException - Thrown on failure
      • updateConglomerateDescriptor

        public void updateConglomerateDescriptor​(ConglomerateDescriptor cd,
                                                 long conglomerateNumber,
                                                 TransactionController tc)
                                          throws StandardException
        Update the conglomerateNumber for a ConglomerateDescriptor. This is useful, in 1.3, when doing a bulkInsert into an empty table where we insert into a new conglomerate. (This will go away in 1.4.)
        Specified by:
        updateConglomerateDescriptor in interface DataDictionary
        Parameters:
        cd - The ConglomerateDescriptor
        conglomerateNumber - The new conglomerate number
        tc - The TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • updateSystemSchemaAuthorization

        public void updateSystemSchemaAuthorization​(java.lang.String aid,
                                                    TransactionController tc)
                                             throws StandardException
        Update all system schemas to have new authorizationId. This is needed while upgrading pre-10.2 databases to 10.2 or later versions. From 10.2, all system schemas would be owned by database owner's authorizationId.
        Parameters:
        aid - AuthorizationID of Database Owner
        tc - TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • updateSchemaAuth

        public void updateSchemaAuth​(java.lang.String schemaName,
                                     java.lang.String authorizationId,
                                     TransactionController tc)
                              throws StandardException
        Update authorizationId of specified schemaName
        Parameters:
        schemaName - Schema Name of system schema
        authorizationId - authorizationId of new schema owner
        tc - The TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • updateConglomerateDescriptor

        public void updateConglomerateDescriptor​(ConglomerateDescriptor[] cds,
                                                 long conglomerateNumber,
                                                 TransactionController tc)
                                          throws StandardException
        Update the conglomerateNumber for an array of ConglomerateDescriptors. In case of more than one ConglomerateDescriptor, each descriptor should be updated separately, conglomerate id is not same for all the descriptors. Even when indexes are sharing the same conglomerate(conglomerate number), conglomerate ids are unique. This is useful, in 1.3, when doing a bulkInsert into an empty table where we insert into a new conglomerate. (This will go away in 1.4.)
        Specified by:
        updateConglomerateDescriptor in interface DataDictionary
        Parameters:
        cds - The array of ConglomerateDescriptors
        conglomerateNumber - The new conglomerate number
        tc - The TransactionController to use
        Throws:
        StandardException - Thrown on failure
      • getDependentsDescriptorList

        public java.util.List<DependencyDescriptor> getDependentsDescriptorList​(java.lang.String dependentID)
                                                                         throws StandardException
        Gets a list of the dependency descriptors for the given dependent's id.
        Specified by:
        getDependentsDescriptorList in interface DataDictionary
        Parameters:
        dependentID - The ID of the dependent we're interested in
        Returns:
        List Returns a list of DependencyDescriptors. Returns an empty List if no stored dependencies for the dependent's ID.
        Throws:
        StandardException - Thrown on failure
      • getProvidersDescriptorList

        public java.util.List<DependencyDescriptor> getProvidersDescriptorList​(java.lang.String providerID)
                                                                        throws StandardException
        Gets a list of the dependency descriptors for the given provider's id.
        Specified by:
        getProvidersDescriptorList in interface DataDictionary
        Parameters:
        providerID - The ID of the provider we're interested in
        Returns:
        List Returns a list of DependencyDescriptors. Returns an empty List if no stored dependencies for the provider's ID.
        Throws:
        StandardException - Thrown on failure
      • dropDependentsStoredDependencies

        public void dropDependentsStoredDependencies​(UUID dependentsUUID,
                                                     TransactionController tc,
                                                     boolean wait)
                                              throws StandardException
        Description copied from interface: DataDictionary
        Remove all of the stored dependencies for a given dependent's ID from the data dictionary.
        Specified by:
        dropDependentsStoredDependencies in interface DataDictionary
        Parameters:
        dependentsUUID - Dependent's uuid
        tc - TransactionController for the transaction
        wait - If true, then the caller wants to wait for locks. False will be when we using a nested user xaction - we want to timeout right away if the parent holds the lock.
        Throws:
        StandardException - Thrown on failure
      • getUUIDFactory

        public UUIDFactory getUUIDFactory()
        Get the UUID Factory. (No need to make the UUIDFactory a module.)
        Specified by:
        getUUIDFactory in interface DataDictionary
        Returns:
        UUIDFactory The UUID Factory for this DataDictionary.
      • getAliasDescriptor

        public AliasDescriptor getAliasDescriptor​(java.lang.String schemaId,
                                                  java.lang.String aliasName,
                                                  char nameSpace)
                                           throws StandardException
        Get a AliasDescriptor by alias name and name space. NOTE: caller responsible for handling no match.
        Specified by:
        getAliasDescriptor in interface DataDictionary
        Parameters:
        schemaId - schema identifier
        aliasName - The alias name.
        nameSpace - The alias type.
        Returns:
        AliasDescriptor AliasDescriptor for the alias name and name space
        Throws:
        StandardException - Thrown on failure
      • getRoutineList

        public java.util.List<AliasDescriptor> getRoutineList​(java.lang.String schemaID,
                                                              java.lang.String routineName,
                                                              char nameSpace)
                                                       throws StandardException
        Get the list of routines matching the schema and routine name. While we only support a single alias for a given name,namespace just return a list of zero or one item. If the schema is SYSFUN then do not use the system catalogs, but instead look up the routines from the in-memory table driven by the contents of SYSFUN_FUNCTIONS.
        Specified by:
        getRoutineList in interface DataDictionary
        Throws:
        StandardException
      • loadDictionaryTables

        private void loadDictionaryTables​(TransactionController tc,
                                          java.util.Properties startParams)
                                   throws StandardException
        Initialize system catalogs. This is where we perform upgrade. It is our pious hope that we won't ever have to upgrade the core catalogs, other than to add fields inside Formatable columns in these catalogs. If we do have to upgrade the core catalogs, then we may need to move the loadCatalog calls into the upgrade machinery. It's do-able, just not pretty.
        Parameters:
        tc - TransactionController
        Throws:
        StandardException - Thrown on error
      • resetDatabaseOwner

        public void resetDatabaseOwner​(TransactionController tc)
                                throws StandardException
        Reset the database owner according to what is stored in the catalogs. This can change at upgrade time so we have factored this logic into a separately callable method.
        Parameters:
        tc - TransactionController
        Throws:
        StandardException - Thrown on error
      • createDictionaryTables

        protected void createDictionaryTables​(java.util.Properties params,
                                              TransactionController tc,
                                              DataDescriptorGenerator ddg)
                                       throws StandardException
        Create all the required dictionary tables. Any classes that extend this class and need to create new tables should override this method, and then call this method as the first action in the new method, e.g.
                        protected Configuration createDictionaryTables(Configuration cfg, TransactionController tc,
                                        DataDescriptorGenerator ddg)
                                        throws StandardException
                        {
                                super.createDictionaryTables(params, tc, ddg);
        
                                ...
                        }
                        
        Throws:
        StandardException - Standard Derby error policy
      • upgradeMakeCatalog

        protected void upgradeMakeCatalog​(TransactionController tc,
                                          int catalogNumber)
                                   throws StandardException
        called by the upgrade code (dd_xena etc) to add a new system catalog.
        Parameters:
        tc - TransactionController to use.
        catalogNumber - catalogNumber
        Throws:
        StandardException
      • upgradeJarStorage

        protected void upgradeJarStorage​(TransactionController tc)
                                  throws StandardException
        Called by the upgrade code to upgrade the way we store jar files in the database.

        We now use UUID as part of the file name to avoid problems with path delimiters. Also, we henceforth use no schema subdirectories since there is no chance of name collision with the UUID.

        Parameters:
        tc - TransactionController to use.
        Throws:
        StandardException
      • upgradeFixSystemColumnDefinition

        public void upgradeFixSystemColumnDefinition​(CatalogRowFactory rowFactory,
                                                     int columnNumber,
                                                     TransactionController tc)
                                              throws StandardException
        Upgrade an existing system catalog column's definition by setting it to the value it would have in a newly created database. This is only used to for a couple of columns that had incorrectly nullability. Other uses (e.g. changing column type) might require more work.
        Parameters:
        columnNumber - The column to change
        tc - Transaction controller
        Throws:
        StandardException - Standard Derby error policy
      • upgrade_addColumns

        public void upgrade_addColumns​(CatalogRowFactory rowFactory,
                                       int[] newColumnIDs,
                                       TransactionController tc)
                                throws StandardException
        Upgrade an existing catalog by adding columns.
        Parameters:
        rowFactory - Associated with this catalog.
        newColumnIDs - Array of 1-based column ids.
        tc - Transaction controller
        Throws:
        StandardException - Standard Derby error policy
      • upgrade_SYSCOLUMNS_AUTOINCCYCLE

        void upgrade_SYSCOLUMNS_AUTOINCCYCLE​(TransactionController tc)
                                      throws StandardException
        Add autoinccycle columns to an SYSCOLUMNS system catalog
        Parameters:
        tc - Transaction controller.
        Throws:
        StandardException - Standard Derby error policy
      • upgrade_addInvisibleColumns

        public void upgrade_addInvisibleColumns​(CatalogRowFactory rowFactory,
                                                int[] newColumnIDs,
                                                TransactionController tc)
                                         throws StandardException
        Add invisible columns to an existing system catalog
        Parameters:
        rowFactory - Associated with this catalog.
        newColumnIDs - Array of 1-based column ids.
        tc - Transaction controller
        Throws:
        StandardException - Standard Derby error policy
      • widenConglomerate

        private void widenConglomerate​(ExecRow templateRow,
                                       int[] newColumnIDs,
                                       long conglomID,
                                       TransactionController tc)
                                throws StandardException
        Adds columns to the conglomerate underlying a system table.
        Parameters:
        templateRow - Ultimate shape of base row of table
        newColumnIDs - Array of 1-based column ids
        conglomID - heap id
        tc - Transaction controller
        Throws:
        StandardException - Standard Derby error policy
      • getUUIDForCoreTable

        private UUID getUUIDForCoreTable​(java.lang.String tableName,
                                         java.lang.String schemaUUID,
                                         TransactionController tc)
                                  throws StandardException
        Get the UUID for the specified system table. Prior to Plato, system tables did not have canonical UUIDs, so we need to scan systables to get the UUID when we are updating the core tables.
        Parameters:
        tableName - Name of the table
        schemaUUID - UUID of schema
        tc - TransactionController to user
        Returns:
        UUID The UUID of the core table.
        Throws:
        StandardException - Thrown on failure
      • upgrade_initSystemTableCols

        void upgrade_initSystemTableCols​(TransactionController tc,
                                         boolean isCoreTable,
                                         int tableNum,
                                         FormatableBitSet columnsToUpdateSet,
                                         DataValueDescriptor[] replaceRow)
                                  throws StandardException
        Initialize noncore columns to fixed values
        Parameters:
        tc - The TransactionController for the transaction to do the upgrade in.
        isCoreTable - true if it is a core table
        tableNum - the noncore table number
        columnsToUpdateSet - a bit set of columns to update. ZERO BASED
        replaceRow - an object array of Orderables for the new values
        Throws:
        StandardException - Thrown on error
      • makeColumnDescriptor

        private ColumnDescriptor makeColumnDescriptor​(SystemColumn column,
                                                      int columnPosition,
                                                      TableDescriptor td)
                                               throws StandardException
        Converts a SystemColumn to a ColumnDescriptor.
        Parameters:
        column - a SystemColumn
        columnPosition - Position of the column in the table, one based.
        td - descriptor for table that column lives in
        Returns:
        a ColumnDes*criptor
        Throws:
        StandardException - Standard Derby error policy
      • createConglomerate

        private long createConglomerate​(java.lang.String name,
                                        TransactionController tc,
                                        ExecRow rowTemplate,
                                        java.util.Properties properties)
                                 throws StandardException
        Create a conglomerate for a system table
        Parameters:
        name - Name of new catalog.
        tc - Transaction context.
        rowTemplate - Template for rows for the new table
        properties - Properties for createConglomerate
        Returns:
        Conglomerate id.
        Throws:
        StandardException - Standard Derby error policy.
      • getIDValueAsCHAR

        private static SQLChar getIDValueAsCHAR​(UUID uuid)
        Converts a UUID to an DataValueDescriptor.
        Returns:
        the UUID converted to an DataValueDescriptor
      • initializeCatalogInfo

        public void initializeCatalogInfo()
                                   throws StandardException
        Initialize catalog information. This method is overridden by children.
        Throws:
        StandardException - Thrown on error
      • initializeNoncoreInfo

        private void initializeNoncoreInfo()
        Initialized the noncore info array.
      • getTransactionCompile

        public TransactionController getTransactionCompile()
                                                    throws StandardException
        Get the TransactionController to use, when not passed in as a parameter. (This hides logic about whether or not we're at boot time in a single place. NOTE: There's no LCC at boot time.) NOTE: All methods in the DD should call this method.
        Returns:
        TransactionController The TC to use.
        Throws:
        StandardException - Thrown on error
      • getTransactionExecute

        public TransactionController getTransactionExecute()
                                                    throws StandardException
        Get the TransactionController to use, when not passed in as a parameter. (This hides logic about whether or not we're at boot time in a single place. NOTE: There's no LCC at boot time.) NOTE: All methods in the DD should call this method.
        Returns:
        TransactionController The TC to use.
        Throws:
        StandardException - Thrown on error
      • getDescriptorViaIndex

        private <T extends TupleDescriptor> T getDescriptorViaIndex​(int indexId,
                                                                    ExecIndexRow keyRow,
                                                                    ScanQualifier[][] scanQualifiers,
                                                                    TabInfoImpl ti,
                                                                    TupleDescriptor parentTupleDescriptor,
                                                                    java.util.List<? super T> list,
                                                                    java.lang.Class<T> returnType,
                                                                    boolean forUpdate)
                                                             throws StandardException
        Return a (single or list of) catalog row descriptor(s) from a system table where the access is from the index to the heap.
        Parameters:
        indexId - The id of the index (0 to # of indexes on table) to use
        keyRow - The supplied ExecIndexRow for search
        ti - The TabInfoImpl to use
        parentTupleDescriptor - The parentDescriptor, if applicable.
        list - The list to build, if supplied. If null, then caller expects a single descriptor
        returnType - The type of descriptor to return
        forUpdate - Whether or not to open the index for update.
        Returns:
        The last matching descriptor
        Throws:
        StandardException - Thrown on error
      • getDescriptorViaIndex

        private <T extends TupleDescriptor> T getDescriptorViaIndex​(int indexId,
                                                                    ExecIndexRow keyRow,
                                                                    ScanQualifier[][] scanQualifiers,
                                                                    TabInfoImpl ti,
                                                                    TupleDescriptor parentTupleDescriptor,
                                                                    java.util.List<? super T> list,
                                                                    java.lang.Class<T> returnType,
                                                                    boolean forUpdate,
                                                                    int isolationLevel,
                                                                    TransactionController tc)
                                                             throws StandardException
        Return a (single or list of) catalog row descriptor(s) from a system table where the access is from the index to the heap. This overload variant takes an explicit tc, in contrast to the normal one which uses the one returned by getTransactionCompile.
        Parameters:
        indexId - The id of the index (0 to # of indexes on table) to use
        keyRow - The supplied ExecIndexRow for search
        ti - The TabInfoImpl to use
        parentTupleDescriptor - The parentDescriptor, if applicable.
        list - The list to build, if supplied. If null, then caller expects a single descriptor
        returnType - The type of descriptor to return
        forUpdate - Whether or not to open the index for update.
        isolationLevel - Use this explicit isolation level. Only ISOLATION_REPEATABLE_READ (normal usage) or ISOLATION_READ_UNCOMMITTED (corner cases) supported for now.
        tc - Transaction controller
        Returns:
        The last matching descriptor. If isolationLevel is ISOLATION_READ_UNCOMMITTED, the base row may be gone by the time we access it via the index; in such a case a null is returned.
        Throws:
        StandardException - Thrown on error.
      • getDescriptorViaHeap

        protected <T extends TupleDescriptor> T getDescriptorViaHeap​(FormatableBitSet columns,
                                                                     ScanQualifier[][] scanQualifiers,
                                                                     TabInfoImpl ti,
                                                                     TupleDescriptor parentTupleDescriptor,
                                                                     java.util.List<? super T> list,
                                                                     java.lang.Class<T> returnType)
                                                              throws StandardException
        Return a (single or list of) catalog row descriptor(s) from a system table where the access a heap scan
        Parameters:
        columns - which columns to fetch from the system table, or null to fetch all columns
        scanQualifiers - qualifiers
        ti - The TabInfoImpl to use
        parentTupleDescriptor - The parentDescriptor, if applicable.
        list - The list to build, if supplied. If null, then caller expects a single descriptor
        returnType - The type of descriptor to look for
        Returns:
        The last matching descriptor
        Throws:
        StandardException - Thrown on error
      • getNonCoreTI

        private TabInfoImpl getNonCoreTI​(int catalogNumber)
                                  throws StandardException
        Get a TabInfoImpl for a non-core table. (We fault in information about non-core tables as needed.)
        Parameters:
        catalogNumber - The index into noncoreTable[].
        Throws:
        StandardException - Thrown on error
      • getNonCoreTIByNumber

        protected TabInfoImpl getNonCoreTIByNumber​(int catalogNumber)
                                            throws StandardException
        returns the tabinfo for a non core system catalog. Input is a catalogNumber (defined in DataDictionary).
        Throws:
        StandardException
      • clearNoncoreTable

        private void clearNoncoreTable​(int nonCoreNum)
      • faultInTabInfo

        private void faultInTabInfo​(TabInfoImpl ti)
                             throws StandardException
        Finishes building a TabInfoImpl if it hasn't already been faulted in. NOP if TabInfoImpl has already been faulted in.
        Parameters:
        ti - TabInfoImpl to fault in.
        Throws:
        StandardException - Thrown on error
      • getSYSCOLUMNSHeapConglomerateNumber

        public long getSYSCOLUMNSHeapConglomerateNumber()
        Get the heap conglomerate number for SYS.SYSCOLUMNS. (Useful for adding new index to the table.)
        Returns:
        The heap conglomerate number for SYS.SYSCOLUMNS.
      • addSYSCOLUMNSIndex2Property

        void addSYSCOLUMNSIndex2Property​(TransactionController tc,
                                         long index2ConglomerateNumber)
      • getBootParameter

        private long getBootParameter​(java.util.Properties startParams,
                                      java.lang.String key,
                                      boolean required)
                               throws StandardException
        Throws:
        StandardException
      • getSystemSQLName

        public java.lang.String getSystemSQLName()
        Returns a unique system generated name of the form SQLyymmddhhmmssxxn yy - year, mm - month, dd - day of month, hh - hour, mm - minute, ss - second, xx - the first 2 digits of millisec because we don't have enough space to keep the exact millisec value, n - number between 0-9 The number at the end is to handle more than one system generated name request came at the same time. In that case, the timestamp will remain the same, we will just increment n at the end of the name. Following is how we get around the problem of more than 10 system generated name requestes at the same time: When the database boots up, we start a counter with value -1 for the last digit in the generated name. We also keep the time in millisec to keep track of when the last system name was generated. At the boot time, it will be default to 0L. In addition, we have a calendar object for the time in millisec That calendar object is used to fetch yy, mm, dd, etc for the string SQLyymmddhhmmssxxn When the first request for the system generated name comes, time of last system generated name will be less than the current time. We initialize the counter to 0, set the time of last system generated name to the current time truncated off to lower 10ms time. The first name request is the only time we know for sure the time of last system generated name will be less than the current time. After this first request, the next request could be at any time. We go through the following algorithm for every generated name request. First check if the current time(truncated off to lower 10ms) is greater than the timestamp for last system generated name If yes, then we change the timestamp for system generated name to the current timestamp and reset the counter to 0 and generate the name using the current timestamp and 0 as the number at the end of the generated name. If no, then it means this request for generated name has come at the same time as last one. Or it may come at a time less than the last generated name request. This could be because of seasonal time change or somebody manually changing the time on the computer. In any case, if the counter is less than 10(meaning this is not yet our 11th request for generated name at a given time), we use that in the generated name. But if the counter has reached 10(which means, this is the 11th name request at the same time), then we increment the system generated name timestamp by 10ms and reset the counter to 0 (notice, at this point, the timestamp for system generated names is not in sync with the real current time, but we need to have this mechanism to get around the problem of more than 10 generated name requests at a same physical time).
        Specified by:
        getSystemSQLName in interface DataDictionary
        Returns:
        system generated unique name
      • twoDigits

        private static java.lang.String twoDigits​(int val)
      • setAutoincrementValue

        public void setAutoincrementValue​(TransactionController tc,
                                          UUID tableUUID,
                                          java.lang.String columnName,
                                          long aiValue,
                                          boolean incrementNeeded)
                                   throws StandardException
        sets a new value in SYSCOLUMNS for a particular autoincrement column.
        Specified by:
        setAutoincrementValue in interface DataDictionary
        Parameters:
        tc - Transaction Controller to use.
        columnName - Name of the column.
        aiValue - Value to write to SYSCOLUMNS.
        incrementNeeded - whether to increment the value passed in by the user (aiValue) or not before writing it to SYSCOLUMNS.
        tableUUID - Table Descriptor
        Throws:
        StandardException
      • computeRowLocation

        private RowLocation computeRowLocation​(TransactionController tc,
                                               TableDescriptor td,
                                               java.lang.String columnName)
                                        throws StandardException
        Computes the RowLocation in SYSCOLUMNS for a particular autoincrement column.
        Parameters:
        tc - Transaction Controller to use.
        td - Table Descriptor.
        columnName - Name of column which has autoincrement column.
        Throws:
        StandardException - thrown on failure.
      • computeSequenceRowLocation

        public void computeSequenceRowLocation​(TransactionController tc,
                                               java.lang.String sequenceIDstring,
                                               RowLocation[] rowLocation,
                                               SequenceDescriptor[] sequenceDescriptor)
                                        throws StandardException
        Computes the RowLocation in SYSSEQUENCES for a particular sequence. Also constructs the sequence descriptor.
        Specified by:
        computeSequenceRowLocation in interface DataDictionary
        Parameters:
        tc - Transaction Controller to use.
        sequenceIDstring - UUID of the sequence as a string
        rowLocation - OUTPUT param for returing the row location
        sequenceDescriptor - OUTPUT param for return the sequence descriptor
        Throws:
        StandardException - thrown on failure.
      • updateCurrentSequenceValue

        public boolean updateCurrentSequenceValue​(TransactionController tc,
                                                  RowLocation rowLocation,
                                                  boolean wait,
                                                  java.lang.Long oldValue,
                                                  java.lang.Long newValue)
                                           throws StandardException
        Set the current value of an ANSI/ISO sequence. This method does not perform any sanity checking but assumes that the caller knows what they are doing. If the old value on disk is not what we expect it to be, then we are in a race with another session. They won and we don't update the value on disk. However, if the old value is null, that is a signal to us that we should update the value on disk anyway.
        Specified by:
        updateCurrentSequenceValue in interface DataDictionary
        Parameters:
        tc - Transaction Controller to use.
        rowLocation - Row in SYSSEQUENCES to update.
        wait - True if we should wait for locks
        oldValue - What we expect to find in the CURRENTVALUE column.
        newValue - What to stuff into the CURRENTVALUE column.
        Returns:
        Returns true if the value was successfully updated, false if we lost a race with another session.
        Throws:
        StandardException - thrown on failure.
      • getCurrentValueAndAdvance

        public void getCurrentValueAndAdvance​(java.lang.String sequenceUUIDstring,
                                              NumberDataValue returnValue)
                                       throws StandardException
        Description copied from interface: DataDictionary
        Get the next number from an ANSI/ISO sequence generator which was created with the CREATE SEQUENCE statement. May raise an exception if the sequence was defined as NO CYCLE and the range of the sequence is exhausted. May allocate a range of sequence numbers and update the CURRENTVALUE column of the corresponding row in SYSSEQUENCES. This work is done in the execution transaction of the current session.
        Specified by:
        getCurrentValueAndAdvance in interface DataDictionary
        Parameters:
        sequenceUUIDstring - String value of the UUID which identifies the sequence
        returnValue - This is a data value to be stuffed with the next sequence number.
        Throws:
        StandardException - if the sequence does not cycle and its range is exhausted
        See Also:
        DataDictionary.getCurrentValueAndAdvance(java.lang.String, org.apache.derby.iapi.types.NumberDataValue)
      • getBulkInsertCounter

        public BulkInsertCounter getBulkInsertCounter​(java.lang.String sequenceUUIDString,
                                                      boolean restart)
                                               throws StandardException
        Description copied from interface: DataDictionary
        Get the identity generator used to support the bulk-insert optimization in InsertResultSet.
        Specified by:
        getBulkInsertCounter in interface DataDictionary
        Parameters:
        sequenceUUIDString - UUID of the sequence which backs the identity column.
        restart - True if the counter should be re-initialized to its start position.
        Throws:
        StandardException
      • flushBulkInsertCounter

        public void flushBulkInsertCounter​(java.lang.String sequenceUUIDString,
                                           BulkInsertCounter bic)
                                    throws StandardException
        Description copied from interface: DataDictionary
        Flush the updated values of the BulkInsertCounter to disk and to the original, cached SequenceUpdater. This is used for the bulk-insert optimization in InsertResultSet.
        Specified by:
        flushBulkInsertCounter in interface DataDictionary
        Parameters:
        sequenceUUIDString - UUID of the sequence which backs the identity column.
        bic - the BulkInsertCounter which generates identities for bulk insert
        Throws:
        StandardException
      • addTableDescriptorToOtherCache

        public void addTableDescriptorToOtherCache​(TableDescriptor td,
                                                   Cacheable c)
                                            throws StandardException
        Add a table descriptor to the "other" cache. The other cache is determined by the type of the object c.
        Parameters:
        td - TableDescriptor to add to the other cache.
        c - Cacheable Object which lets us figure out the other cache.
        Throws:
        StandardException
      • newSystemSchemaDesc

        private SchemaDescriptor newSystemSchemaDesc​(java.lang.String name,
                                                     java.lang.String uuid)
      • newDeclaredGlobalTemporaryTablesSchemaDesc

        private SchemaDescriptor newDeclaredGlobalTemporaryTablesSchemaDesc​(java.lang.String name)
      • checkVersion

        public boolean checkVersion​(int requiredMajorVersion,
                                    java.lang.String feature)
                             throws StandardException
        Check to see if a database has been upgraded to the required level in order to use a language feature.
        Specified by:
        checkVersion in interface DataDictionary
        Parameters:
        requiredMajorVersion - Data Dictionary major version
        feature - Non-null to throw an error, null to return the state of the version match.
        Returns:
        True if the database has been upgraded to the required level, false otherwise.
        Throws:
        StandardException
      • isReadOnlyUpgrade

        public boolean isReadOnlyUpgrade()
        Description copied from interface: DataDictionary
        Check if the database is read only and requires some form of upgrade that makes the stored prepared statements invalid.
        Specified by:
        isReadOnlyUpgrade in interface DataDictionary
        Returns:
        true if the stored prepared statements are invalid because of an upgrade and the database is read only, false otherwise
      • setReadOnlyUpgrade

        void setReadOnlyUpgrade()
        Mark this database as a read only database whose stored prepared statements are invalid because some kind of upgrade is needed.
      • createSystemProcedureOrFunction

        private final UUID createSystemProcedureOrFunction​(java.lang.String routine_name,
                                                           UUID schema_uuid,
                                                           java.lang.String[] arg_names,
                                                           TypeDescriptor[] arg_types,
                                                           int num_out_param,
                                                           int num_result_sets,
                                                           short routine_sql_control,
                                                           boolean isDeterministic,
                                                           boolean hasVarargs,
                                                           TypeDescriptor return_type,
                                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines,
                                                           TransactionController tc,
                                                           java.lang.String procClass)
                                                    throws StandardException
        Generic create procedure routine.

        Takes the input procedure and inserts it into the appropriate catalog. Assumes all arguments are "IN" type.

        Parameters:
        routine_name - name of the routine in java and the SQL procedure name.
        arg_names - String array of procedure argument names in order.
        arg_types - Internal SQL types of the arguments
        routine_sql_control - One of the RoutineAliasInfo constants: MODIFIES_SQL_DATA READS_SQL_DATA CONTAINS_SQL NO_SQL
        isDeterministic - True if the procedure/function is DETERMINISTIC
        return_type - null for procedure. For functions the return type of the function.
        newlyCreatedRoutines - evolving set of routines, some of which may need permissions later on
        tc - an instance of the TransactionController
        procClass - the fully qualified name of the class that contains java definitions for the stored procedures
        Returns:
        UUID UUID of system routine that got created.
        Throws:
        StandardException - Standard exception policy.
      • createSystemProcedureOrFunction

        private final UUID createSystemProcedureOrFunction​(java.lang.String routine_name,
                                                           UUID schema_uuid,
                                                           java.lang.String[] arg_names,
                                                           TypeDescriptor[] arg_types,
                                                           int num_out_param,
                                                           int num_result_sets,
                                                           short routine_sql_control,
                                                           boolean isDeterministic,
                                                           boolean hasVarargs,
                                                           TypeDescriptor return_type,
                                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines,
                                                           TransactionController tc)
                                                    throws StandardException
        Generic create procedure routine. Takes the input procedure and inserts it into the appropriate catalog. Assumes all arguments are "IN" type.
        Parameters:
        routine_name - name of the routine in java and the SQL procedure name.
        arg_names - String array of procedure argument names in order.
        arg_types - Internal SQL types of the arguments
        routine_sql_control - One of the RoutineAliasInfo constants: MODIFIES_SQL_DATA READS_SQL_DATA CONTAINS_SQL NO_SQL
        isDeterministic - True if the procedure/function is DETERMINISTIC
        return_type - null for procedure. For functions the return type of the function.
        newlyCreatedRoutines - evolving set of routines, some of which may need permissions later on
        tc - an instance of the TransactionController
        Returns:
        UUID UUID of system routine that got created.
        Throws:
        StandardException - Standard exception policy.
      • create_SYSCS_procedures

        private final void create_SYSCS_procedures​(TransactionController tc,
                                                   java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                            throws StandardException
        Create system procedures

        Used to add the system procedures to the database when it is created. System procedures are currently added to either SYSCS_UTIL or SQLJ schemas.

        Parameters:
        tc - transaction controller to use. Counts on caller to commit.
        newlyCreatedRoutines - evolving set of routines which may need to be given permissions later on
        Throws:
        StandardException - Standard exception policy.
      • create_SYSIBM_procedures

        protected final void create_SYSIBM_procedures​(TransactionController tc,
                                                      java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                               throws StandardException
        Create system procedures in SYSIBM

        Used to add the system procedures to the database when it is created. Full upgrade from version 5.1 or earlier also calls this method.

        Parameters:
        newlyCreatedRoutines - evolving set of routines which we're adding (some may need permissions later on)
        tc - transaction controller to use. Counts on caller to commit.
        Throws:
        StandardException - Standard exception policy.
      • grantPublicAccessToSystemRoutines

        public void grantPublicAccessToSystemRoutines​(java.util.HashSet newlyCreatedRoutines,
                                                      TransactionController tc,
                                                      java.lang.String authorizationID)
                                               throws StandardException
        Grant PUBLIC access to specific system routines. Currently, this is done for some routines in SYSCS_UTIL schema. We grant access to routines which we have just added. Doing it this way lets us declare these routines in one place and re-use this logic during database creation and during upgrade.
        Parameters:
        tc - TransactionController to use
        authorizationID - authorization ID of the permission grantor
        Throws:
        StandardException - Standard exception policy.
      • grantPublicAccessToSystemRoutine

        private void grantPublicAccessToSystemRoutine​(java.lang.String schemaID,
                                                      java.lang.String routineName,
                                                      char nameSpace,
                                                      TransactionController tc,
                                                      java.lang.String authorizationID)
                                               throws StandardException
        Grant PUBLIC access to a system routine. This method should be used only for granting access to a system routine (other than routines in SYSFUN schema). It expects the routine to be present in SYSALIASES catalog.
        Parameters:
        schemaID - Schema ID
        routineName - Routine Name
        nameSpace - Indicates whether the routine is a function/procedure.
        tc - TransactionController to use
        authorizationID - authorization ID of the permission grantor
        Throws:
        StandardException - Standard exception policy.
      • createRoutinePermPublicDescriptor

        void createRoutinePermPublicDescriptor​(UUID routineUUID,
                                               TransactionController tc,
                                               java.lang.String authorizationID)
                                        throws StandardException
        Create RoutinePermDescriptor to grant access to PUBLIC for this system routine using the grantor specified in authorizationID.
        Parameters:
        routineUUID - uuid of the routine
        tc - TransactionController to use
        authorizationID - authorization ID of the permission grantor
        Throws:
        StandardException - Standard exception policy.
      • create_10_1_system_procedures

        void create_10_1_system_procedures​(TransactionController tc,
                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines,
                                           UUID sysUtilUUID)
                                    throws StandardException
        Create system procedures added in version 10.1.

        Create 10.1 system procedures, called by either code creating new database, or code doing hard upgrade from previous version.

        Parameters:
        tc - booting transaction
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        sysUtilUUID - uuid of the SYSUTIL schema.
        Throws:
        StandardException - Standard exception policy.
      • create_10_2_system_procedures

        void create_10_2_system_procedures​(TransactionController tc,
                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines,
                                           UUID sysUtilUUID)
                                    throws StandardException
        Create system procedures added in version 10.2.

        Create 10.2 system procedures, called by either code creating new database, or code doing hard upgrade from previous version.

        Parameters:
        tc - booting transaction
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        sysUtilUUID - uuid of the SYSUTIL schema.
        Throws:
        StandardException - Standard exception policy.
      • create_10_3_system_procedures_SYSIBM

        private void create_10_3_system_procedures_SYSIBM​(TransactionController tc,
                                                          java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                                   throws StandardException
        Create system procedures added in version 10.3. Create 10.3 system procedures related to the LOB Methods , called by either code creating new database, or code doing hard upgrade from previous version.
        Parameters:
        tc - an instance of the TransactionController class.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException - Standard exception policy.
      • create_10_5_system_procedures

        void create_10_5_system_procedures​(TransactionController tc,
                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                    throws StandardException
        Create the System procedures that are added to 10.5.
        Parameters:
        tc - an instance of the TransactionController.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException - Standard exception policy.
      • create_10_6_system_procedures

        void create_10_6_system_procedures​(TransactionController tc,
                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                    throws StandardException
        Create the System procedures that are added to 10.6.
        Parameters:
        tc - an instance of the TransactionController.
        Throws:
        StandardException - Standard exception policy.
      • create_10_3_system_procedures

        void create_10_3_system_procedures​(TransactionController tc,
                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                    throws StandardException
        Create the System procedures that are added in 10.3.
        Parameters:
        tc - an instance of the TransactionController.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException - Standard exception policy.
      • create_10_3_system_procedures_SYSCS_UTIL

        void create_10_3_system_procedures_SYSCS_UTIL​(TransactionController tc,
                                                      java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                               throws StandardException
        Create system procedures that are part of the SYSCS_UTIL schema added in version 10.3.

        Create 10.3 system procedures, called by either code creating new database, or code doing hard upgrade from previous version.

        Parameters:
        tc - an instance of the Transaction Controller.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException - Standard exception policy.
      • create_10_9_system_procedures

        void create_10_9_system_procedures​(TransactionController tc,
                                           java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                    throws StandardException

        Create system procedures that are part of the SYSCS_UTIL schema added in version 10.9. These include the procedures for managing NATIVE credentials. See DERBY-866.

        Parameters:
        tc - an instance of the Transaction Controller.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException
      • create_10_10_system_procedures

        void create_10_10_system_procedures​(TransactionController tc,
                                            java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                     throws StandardException

        Create system procedures that are part of the SYSCS_UTIL schema, added in version 10.10.

        Parameters:
        tc - an instance of the Transaction Controller.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException
      • create_10_11_system_procedures

        void create_10_11_system_procedures​(TransactionController tc,
                                            java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                     throws StandardException

        Create system procedures that are part of the SYSCS_UTIL schema, added in version 10.11.

        Parameters:
        tc - an instance of the Transaction Controller.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException
      • create_10_12_system_procedures

        void create_10_12_system_procedures​(TransactionController tc,
                                            java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                     throws StandardException

        Create system procedures that are part of the SYSCS_UTIL schema, added in version 10.12.

        Parameters:
        tc - an instance of the Transaction Controller.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException
      • create_10_13_system_procedures

        void create_10_13_system_procedures​(TransactionController tc,
                                            java.util.HashSet<java.lang.String> newlyCreatedRoutines)
                                     throws StandardException

        Create system procedures that are part of the SYSCS_UTIL schema, added in version 10.13.

        Parameters:
        tc - an instance of the Transaction Controller.
        newlyCreatedRoutines - set of routines we are creating (used to add permissions later on)
        Throws:
        StandardException
      • getQueryDescriptions

        private final java.util.Properties getQueryDescriptions​(boolean net)
      • run

        public final java.util.Properties run()
        Specified by:
        run in interface java.security.PrivilegedAction<java.util.Properties>
      • newSList

        private static <T> java.util.List<T> newSList()
      • getColumnPermissions

        public ColPermsDescriptor getColumnPermissions​(UUID tableUUID,
                                                       int privType,
                                                       boolean forGrant,
                                                       java.lang.String authorizationId)
                                                throws StandardException
        Get one user's column privileges for a table.
        Specified by:
        getColumnPermissions in interface DataDictionary
        Parameters:
        tableUUID -
        privType - (as int) Authorizer.SELECT_PRIV, Authorizer.UPDATE_PRIV, or Authorizer.REFERENCES_PRIV
        forGrant -
        authorizationId - The user name
        Returns:
        a ColPermsDescriptor or null if the user has no separate column permissions of the specified type on the table. Note that the user may have been granted permission on all the columns of the table (no column list), in which case this routine will return null. You must also call getTablePermissions to see if the user has permission on a set of columns.
        Throws:
        StandardException
      • getColumnPermissions

        public ColPermsDescriptor getColumnPermissions​(UUID tableUUID,
                                                       java.lang.String privTypeStr,
                                                       boolean forGrant,
                                                       java.lang.String authorizationId)
                                                throws StandardException
        Get one user's column privileges for a table. This routine gets called during revoke privilege processing
        Specified by:
        getColumnPermissions in interface DataDictionary
        Parameters:
        tableUUID -
        privTypeStr - (as String) Authorizer.SELECT_PRIV, Authorizer.UPDATE_PRIV, or Authorizer.REFERENCES_PRIV
        forGrant -
        authorizationId - The user name
        Returns:
        a ColPermsDescriptor or null if the user has no separate column permissions of the specified type on the table. Note that the user may have been granted permission on all the columns of the table (no column list), in which case this routine will return null. You must also call getTablePermissions to see if the user has permission on a set of columns.
        Throws:
        StandardException
      • addRemovePermissionsDescriptor

        public boolean addRemovePermissionsDescriptor​(boolean add,
                                                      PermissionsDescriptor perm,
                                                      java.lang.String grantee,
                                                      TransactionController tc)
                                               throws StandardException
        Add or remove a permission to/from the permission database.
        Specified by:
        addRemovePermissionsDescriptor in interface DataDictionary
        Parameters:
        add - if true then the permission is added, if false the permission is removed
        perm -
        grantee -
        tc -
        Returns:
        True means revoke has removed a privilege from system table and hence the caller of this method should send invalidation actions to PermssionDescriptor's dependents.
        Throws:
        StandardException
      • getUncachedTablePermsDescriptor

        TablePermsDescriptor getUncachedTablePermsDescriptor​(TablePermsDescriptor key)
                                                      throws StandardException
        Get a table permissions descriptor from the system tables, without going through the cache. This method is called to fill the permissions cache.
        Returns:
        a TablePermsDescriptor that describes the table permissions granted to the grantee, null if no table-level permissions have been granted to him on the table.
        Throws:
        StandardException
      • getUncachedColPermsDescriptor

        ColPermsDescriptor getUncachedColPermsDescriptor​(ColPermsDescriptor key)
                                                  throws StandardException
        Get a column permissions descriptor from the system tables, without going through the cache. This method is called to fill the permissions cache.
        Returns:
        a ColPermsDescriptor that describes the column permissions granted to the grantee, null if no column permissions have been granted to him on the table.
        Throws:
        StandardException
      • getUncachedRoutinePermsDescriptor

        RoutinePermsDescriptor getUncachedRoutinePermsDescriptor​(RoutinePermsDescriptor key)
                                                          throws StandardException
        Get a routine permissions descriptor from the system tables, without going through the cache. This method is called to fill the permissions cache.
        Returns:
        a RoutinePermsDescriptor that describes the table permissions granted to the grantee, null if no table-level permissions have been granted to him on the table.
        Throws:
        StandardException
      • getVTIClass

        public java.lang.String getVTIClass​(TableDescriptor td,
                                            boolean asTableFunction)
                                     throws StandardException
        Description copied from interface: DataDictionary
        Return the Java class to use for the VTI to which the received table descriptor maps. There are two kinds of VTI mappings that we do: the first is for "table names", the second is for "table function names". Table names can only be mapped to VTIs that do not accept any arguments; any VTI that has at least one constructor which accepts one or more arguments must be mapped from a table *function* name. An example of a VTI "table name" is the following: select * from SYSCS_DIAG.LOCK_TABLE In this case "SYSCS_DIAG.LOCK_TABLE" is the table name that we want to map. Since the corresonding VTI does not accept any arguments, this VTI table name can be used anywhere a normal base table name can be used. An example of a VTI "table function name" is the following: select * from TABLE(SYSCS_DIAG.SPACE_TABLE(?)) x In this case "SYSCS_DIAG.SPACE_TABLE" is the table function name that we want to map. Since the corresponding VTI can take either one or two arguments we have to use the TABLE constructor syntax to pass the argument(s) in as if we were making a function call. Hence the term "table function".
        Specified by:
        getVTIClass in interface DataDictionary
        Parameters:
        td - Table descriptor used for the VTI look-up.
        asTableFunction - If false then treat td's descriptor name as a VTI "table name"; if true, treat the descriptor name as a VTI "table function name".
        Returns:
        Java class name to which "td" maps, or null if no mapping is found.
        Throws:
        StandardException
        See Also:
        DataDictionary.getVTIClass(TableDescriptor, boolean)
      • existsGrantToAuthid

        public boolean existsGrantToAuthid​(java.lang.String authId,
                                           TransactionController tc)
                                    throws StandardException
        Check all dictionary tables and return true if there is any GRANT descriptor containing authId as its grantee.
        Specified by:
        existsGrantToAuthid in interface DataDictionary
        Parameters:
        authId - grantee for which a grant exists or not
        tc - TransactionController for the transaction
        Returns:
        boolean true if such a grant exists
        Throws:
        StandardException
      • getSequenceID

        private java.lang.String getSequenceID​(java.lang.String schemaName,
                                               java.lang.String sequenceName)
                                        throws StandardException

        Get the uuid string of a sequence given its schema and sequence name.

        Throws:
        StandardException
      • getUncachedGenericPermDescriptor

        PermDescriptor getUncachedGenericPermDescriptor​(PermDescriptor key)
                                                 throws StandardException
        Get an object's permission descriptor from the system tables, without going through the cache. This method is called to fill the permissions cache.
        Returns:
        a PermDescriptor that describes the table permissions granted to the grantee on an objcet , null if no table-level permissions have been granted to him on the table.
        Throws:
        StandardException
      • getGenericPermissions

        public PermDescriptor getGenericPermissions​(UUID objectUUID,
                                                    java.lang.String objectType,
                                                    java.lang.String privilege,
                                                    java.lang.String granteeAuthId)
                                             throws StandardException
        Get permissions granted to one user for an object using the object's Id and the user's authorization Id.
        Specified by:
        getGenericPermissions in interface DataDictionary
        Parameters:
        objectUUID - The id of the protected object
        objectType - Type of the object (e.g., SEQUENCE)
        privilege - The kind of privilege needed (e.g., PermDescriptor.USAGE_PRIV)
        granteeAuthId - The user or role who wants to have permission on this object
        Returns:
        The descriptor of the permissions for the object
        Throws:
        StandardException
      • getIndexStatsRefresher

        public IndexStatisticsDaemon getIndexStatsRefresher​(boolean asDaemon)
        Returns the index statistics refresher.
        Specified by:
        getIndexStatsRefresher in interface DataDictionary
        Parameters:
        asDaemon - whether the usage is automatic (true) or explicit (false)
        Returns:
        The index statistics refresher instance, or null if disabled. If asDaemon is false, an instance will always be returned.
      • disableIndexStatsRefresher

        public void disableIndexStatsRefresher()
        Disables automatic refresh/creation of index statistics at runtime.

        If the daemon is disabled, it can only be enabled again by rebooting the database. Note that this method concerns diabling the daemon at runtime, and only the automatic updates of statistics. If wanted, the user would disable the daemon at boot-time by setting a property (system-wide or database property).

        Usage note: This method was added to allow the index refresher itself to notify the data dictionary that it should be disabled. This only happens if the refresher/daemon experiences severe errors, or a large amount of errors. It would then disable itself to avoid eating up system resources and potentially cause side-effects due to the errors.

        Specified by:
        disableIndexStatsRefresher in interface DataDictionary
      • doCreateIndexStatsRefresher

        public boolean doCreateIndexStatsRefresher()
        Tells if an index statistics refresher should be created for this database.

        The only reason not to create an index statistics refresher is if one already exists.

        Specified by:
        doCreateIndexStatsRefresher in interface DataDictionary
        Returns:
        true if an index statistics refresher should be created, false if one already exists.
      • createIndexStatsRefresher

        public void createIndexStatsRefresher​(Database db,
                                              java.lang.String dbName)
        Creates an index statistics refresher for this data dictionary.

        The index statistics refresher is used to create and refresh index cardinality statistics, either automatically or on user demand (i.e. by invoking SYSCS_UTIL.SYSCS_UPDATE_STATISTICS).

        Specified by:
        createIndexStatsRefresher in interface DataDictionary
        Parameters:
        db - the database object associated with this data dictionary
        dbName - the name of the database
      • getDependableFinder

        public DependableFinder getDependableFinder​(int formatId)
        Description copied from interface: DataDictionary
        Get a DependableFinder instance.
        Specified by:
        getDependableFinder in interface DataDictionary
        Parameters:
        formatId - the format id
        Returns:
        an instance capable of finding Dependables with the specified format id
      • getColumnDependableFinder

        public DependableFinder getColumnDependableFinder​(int formatId,
                                                          byte[] columnBitMap)
        Description copied from interface: DataDictionary
        Get a DependableFinder instance for referenced columns in a table.
        Specified by:
        getColumnDependableFinder in interface DataDictionary
        Parameters:
        formatId - the format id
        columnBitMap - byte array encoding the bitmap of referenced columns
        Returns:
        an instance capable of finding Dependables with the specified format id
      • getContextService

        private static ContextService getContextService()
        Privileged lookup of the ContextService. Must be private so that user code can't call this entry point.
      • getContextOrNull

        private static Context getContextOrNull​(java.lang.String contextID)
        Privileged lookup of a Context. Must be private so that user code can't call this entry point.
      • getContext

        private static Context getContext​(java.lang.String contextID)
        Privileged lookup of a Context. Must be private so that user code can't call this entry point.
      • getMonitor

        static ModuleFactory getMonitor()
        Privileged Monitor lookup. Must be package private so that user code can't call this entry point.
      • startSystemModule

        private static java.lang.Object startSystemModule​(java.lang.String factoryInterface)
                                                   throws StandardException
        Privileged startup. Must be private so that user code can't call this entry point.
        Throws:
        StandardException
      • bootServiceModule

        private static java.lang.Object bootServiceModule​(boolean create,
                                                          java.lang.Object serviceModule,
                                                          java.lang.String factoryInterface,
                                                          java.util.Properties properties)
                                                   throws StandardException
        Privileged startup. Must be private so that user code can't call this entry point.
        Throws:
        StandardException
      • findServiceModule

        private static java.lang.Object findServiceModule​(java.lang.Object serviceModule,
                                                          java.lang.String factoryInterface)
                                                   throws StandardException
        Privileged startup. Must be private so that user code can't call this entry point.
        Throws:
        StandardException