All Classes and Interfaces

Class
Description
An abstract implementation of LockFactory that allows different implementations of the lock table to be plugged in.
This class will perform the database connection establishment, querying the database, shut downing the database.
Module interface for an access manager.
Global constants provided by the Access Interface.
This allows us to get to the byte array to go back and edit contents or get the array without having a copy made.
AccessPath represents a proposed access path for an Optimizable.
 
An activation contains all the local state information necessary to execute a re-entrant PreparedStatement.
ActivationClassBuilder provides an interface to satisfy generation's common tasks in building an activation class, as well as a repository for the JavaFactory used to generate the basic language constructs for the methods in the class.
A Lock represents a granted or waiting lock request.
 
Describe a G (Aggregate) alias.
An AggregateDefinition defines an aggregate.
An Aggregate Node is a node that represents a set function/aggregate.
 
This sort observer performs aggregation.
Represents aggregate function calls on a window
Behavior of a user-defined Derby aggregator.
This is a simple class used to store the run time information needed to invoke an aggregator.
Vector of AggergatorInfo objects.
This class represents an Alias Descriptor.
An interface for describing an alias in Derby systems.
This interface describe the operations that has to do with page allocation/deallocation.
An auxiliary object to cache the allocation information for a file container.
An allocation extent row manages the page status of page in the extent.
An allocation page of the file container.
 
An AllResultColumn represents a "*" result column in a SELECT statement.
This class describes actions that are ALWAYS performed for a alter constraint at Execution time.
This class describes actions that are ALWAYS performed for an ALTER TABLE Statement at Execution time.
A AlterTableNode represents a DDL statement that alters a table.
 
Used for deferrable CHECK constraint.
Takes a quantified predicate subquery's result set.
An object input stream that implements resolve class in order to load the class through the ClassFactory.loadApplicationClass method.
AppRequester stores information about the application requester.
An InputStream that allows reading from an array of bytes.
 
Utility class for constructing and reading and writing arrays from/to formatId streams and for performing other operations on arrays.
 
AssertFailure is raised when an ASSERT check fails.
A Visitor which handles nodes in Derby's abstract syntax trees.
Does asynchronous shipping of log records from the master to the slave being replicated to.
 
List of all connection (JDBC) attributes by the system.
List of all connection (JDBC) attributes by the system.
 
 
 
The AuthenticationService provides a mechanism for authenticating users willing to access JBMS.
This is the authentication service base class.
The Authorizer verifies a connected user has the authorization to perform a requested database operation using the current connection.
AutoincrementCounter is a not so general counter for the specific purposes of autoincrement columns.
This is the dummy driver which is registered with the DriverManager and which is autoloaded by JDBC4.
This Stream is a wrapper for PositionedStoreStream to set the position correctly before performing any operation on it.
The interface of objects which can be associated with a page while it's in cache.
Aggregator for AVG().
Interface describing a table function which can be given information about the context in which it runs.
Implements an instance of a B-Tree secondary index conglomerate.
Class used to instantiate 10.3 version of the B2I object.
Class used to instantiate 10.2 version of the B2I object.
Controller used to insert rows into a secondary index.
Controller used to provide cost estimates to optimizer about secondary index data access.
The "B2I" (acronym for b-tree secondary index) factory manages b-tree conglomerates implemented on the raw store which are used as secondary indexes.
The btree secondary index implementation of ScanManager which provides reading and deleting of entries in the btree secondary index.
Scan used to find maximum value in the secondary index.
Secondary index locking policy that does no locking.
The btree locking policy which implements read uncommitted isolation level.
The btree locking policy which implements read committed isolation level.
Implements the jdbc serializable isolation level using row locks.
 
This class implements the static compiled information relevant to a btree secondary index.
 
The B2IUndo interface packages up the routines which the rawstore needs to call to perform logical undo of a record in a B2i.
A background cleaner that ConcurrentCache can use to clean Cacheables asynchronously in a background instead of synchronously in the user threads.
A BackingStoreHashtable is a utility class which will store a set of rows into an in memory hash table, or overflow the hash table to a tempory on disk structure.
List of DataValueDescriptor[] instances that represent rows.
Extend BackingStoreHashtable with the ability to maintain the underlying openScan() until the hashtable has been closed.
BaseActivation provides the fundamental support we expect all activations to have.
A BaseColumnNode represents a column in a base table.
BaseContainer is an abstract class that provides the locking bahaviour for an object representing an active container, that is the actual storage container, not the ContainerHandle interface.
A handle to an open container, implememts RawContainerHandle.
Provides the abstract class with most of the implementation of DataFactory and ModuleControl shared by all the different filesystem implementations.
This class overloads BaseDataFileFactory to produce RAFContainer4 objects instead of RAFContainer objects.
BaseExpressionActivation Support needed by Expression evaluators (Filters) and by ResultSet materializers (Activations)
 
Implementation of the monitor that uses the class loader that the its was loaded in for all class loading.
This class implements all the the generic locking behaviour for a Page.
This class provides a base for implementations of the StorageFactory interface.
Walk through a subtree and build a list of the assigned numbers for all tables that exist in that subtree.
This is the base implementation of TypeCompiler
This class is the base class for all type ids that are written to the system tables.
This authentication service is the basic Derby user authentication level support.
This data source is suitable for client/server use of Derby, running on Java 8 Compact Profile 2 or higher.
This data source is suitable for client/server use of Derby, running on Java 8 Compact Profile 2 or higher.
This data source is suitable for client/server use of Derby, running on Java 8 Compact Profile 2 or higher.
A BasicDaemon is a background worker thread which does asynchronous I/O and general clean up.
The Database interface provides control over the physical database (that is, the stored data and the files the data are stored in), connections to the database, operations on the database such as backup and recovery, and all other things that are associated with the database itself.
A dependency represents a reliance of the dependent on the provider for some information the dependent contains or uses.
The dependency manager tracks needs that dependents have of providers.
This data source is suitable for an application using embedded Derby, running on Java 8 Compact Profile 2 or higher.
This data source is suitable for an application using embedded Derby, running on Java 8 Compact Profile 2 or higher.
This data source is suitable for an application using embedded Derby, running on Java 8 Compact Profile 2 or higher.
Get a header to prepend to a line of output. * A HeaderPrintWriter requires an object which implements this interface to construct line headers.
Basic class to print lines with headers.
Abstract ResultSet for for operations that return rows but do not allow the caller to put data on output pipes.
 
This is the implementation of ProviderInfo in the DependencyManager.
This is the most basic sort observer.
 
A hack implementation of something similar to a DCE UUID generator.
 
ClassBuilder is used to construct a java class's byte array representation.
To be able to identify the expressions as belonging to this implementation, and to be able to generate code off of it if so.
Debugging problems with generated classes
 
MethodBuilder is used to piece together a method when building a java class definition.
 
A method descriptor.
This operation indicates the beginning of a transaction.
A BetweenOperatorNode represents a BETWEEN clause.
This node represents a binary arithmetic operator, like + or *.
This node is the superclass for all binary comparison operators, such as =, <>, <, etc.
A BinaryListOperatorNode represents a built-in "binary" operator with a single operand on the left of the operator and a list of operands on the right.
 
A BinaryOperatorNode represents a built-in binary operator as defined by the ANSI/ISO SQL standard.
The Orderable interface represents a value that can be linearly ordered.
The BinaryOrderableWrapper is a wrapper class which intercepts the readExternal() callback made by raw store during a fetch, and does a comparison instead.
This class represents the 6 binary operators: LessThan, LessThanEquals, Equals, NotEquals, GreaterThan and GreaterThanEquals.
Converts a stream containing the Derby stored binary form to one that just contains the application's data.
 
 
This class implements TypeCompiler for the SQL BIT datatype.
An InputStream that will use an locator to fetch the Blob value from the server.
An OutputStream that will use an locator to write bytes to the Blob value on the server.
 
Stores data in blocks, and supports reading/writing data from/into these blocks.
An input stream reading from a blocked byte array.
Output stream writing bytes into an underlying blocked byte array.
 
 
This class implements TypeCompiler for the SQL BOOLEAN datatype.
A branch row contains key fields and the pointer to the child page.
Implements row which is stored in the branch pages of a btree.
Brokered CallableStatement.
 
This is a rudimentary connection that delegates EVERYTHING to Connection.
 
Provides control over a BrokeredConnection
A brokered PreparedStatement that forwards calls off to a real PreparedStatement obtained through the BrokeredStatementControl.getRealPreparedStatement() method.
 
A Statement implementation that forwards all of its requests to an underlying Statement.
Provides control over a BrokeredStatement, BrokeredPreparedStatement or BrokeredCallableStatement
A b-tree object corresponds to an instance of a b-tree conglomerate.
A b-tree controller corresponds to an instance of an open b-tree conglomerate.
The StoreCostController interface provides methods that an access client (most likely the system optimizer) can use to get store's estimated cost of various operations on the conglomerate the StoreCostController was opened for.
A b-tree scan controller corresponds to an instance of an open b-tree scan.
The generic.BTree directory wants to know as little about locking as possible, in order to make the code usuable by multiple implementations.
A BTreeScan implementation that provides the 95% solution to the max on btree problem.
The BTreePostCommit class implements the Serviceable protocol.
 
A b-tree scan controller corresponds to an instance of an open b-tree scan.
This object provides performance information related to an open scan.
 
Thin wrapper around a sequence generator to support the bulk-insert optimization used by InsertResultSet.
Read a base table or index in bulk.
 
ByteArray wraps java byte arrays (byte[]) to allow byte arrays to be used as keys in hashtables.
A stream whose source is a list of byte arrays.
Holder for a growing sequence of bytes.
 
Constants for the LockFactory
The purpose of this interface is to hold the constant definitions of the different node type identifiers, for use with NodeFactory.
Any object that implements this interface can be cached using the services of the CacheManager/CacheFactory.
The CacheableConglomerate implements a single item in the cache used by the Conglomerate directory to cache Conglomerates.
Any object that implements this interface can be cached using the services of the CacheManager/CacheFactory.
A base page that is cached.
 
A wrapper class for a ValueNode that is referenced multiple places in the abstract syntax tree, but should only be evaluated once.
Class representing an entry in the cache.
A factory for handing out caches.
Only used for exclusive lock purposes.
 
This is an MBean that provides information about one of Derby's cache managers.
A logical connection used in a connection pool with capabilities for caching prepared statements.
Contains the necessary methods to call the stored procedure that operate on LOBs identified by locators.
An CallStatementNode represents a CALL statement.
Call a Java procedure.
This is a decorator (in Design Patterns Terminology) class to enhance the functionality of a RowLocationRetRowSource.
An CastNode represents a cast expression.
Superclass of all row factories.
 
 
 
 
A description of a byte stream representing characters.
The builder for the CharacterStreamDescriptor class.
 
This interface describes a character stream that maintains line and column number positions of the characters.
Generates stream headers for non-Clob string data types.
This class implements TypeCompiler for the SQL char datatypes.
This class represents a check constraint descriptor.
A Log Operation that represents a checkpoint.
A Log Operation that represents a checksum for a group of log records that are written to the tranaction log file.
A CipherFactory can create new CipherProvider, which is a wrapper for a javax.crypto.Cipher This service is only available when run on JDK1.2 or beyond.
 
A CipherProvider is a wrapper for a Cipher class in JCE.
ClassBuilder is used to construct a java class's byte array representation.
An enumeration that filters only classes from the enumeration of the class pool.
A class factory module to handle application classes and generated classes.
Context that provides the correct ClassFactory for the current service.
A wrapper around DataOutputStream to provide input functions in terms of the types defined on pages 83 of the Java Virtual Machine spec.
Based upon "THE class FILE FORMAT" chapter of "The Java Virtual Machine Specification" corresponding to version 1.0.2 of the Java Virtual Machine and 1.0.2 of the Java Language Specification.
 
A wrapper around DataInputStream to provide input functions in terms of the types defined on pages 83.
Methods to find out relationships between classes and methods within a class.
 
 
 
List of strings representing class names, which are typically found for classes with implement the Formatable interface.
 
Map from class names to size coefficients.
 
 
 
This class implements the JDBC java.sql.Clob interface.
 
This datasource is suitable for a client/server use of Derby, running on full Java SE 6 and higher, corresponding to JDBC 4.0 and higher.
Deprecated.
Specifies Derby extensions to the java.sqlx.ConnectionPoolDataSource.
 
This data source is suitable for a client/server use of Derby, running on full Java SE 6 and higher, corresponding to JDBC 4.0 and higher.
Deprecated.
Use ClientDataSource instead.
The data source factory for Derby client driver data sources.
Specifies Derby extensions to the java.sqlx.DataSource API common to all Derby client driver data sources.
The client JDBC driver (type 4) for Derby.
Adds driver functionality which is only visible from JDBC 4.0 onward.
The methods of this interface are used to return JDBC interface implementations to the user depending on the JDBC version supported by the JDK.
Implements the the ClientJDBCObjectFactory interface and returns the classes that implement the JDBC3.0/2.0 interfaces For example, newCallableStatement would return ClientCallableStatement
Implements the ClientJDBCObjectFactory interface and returns the JDBC 4.2 specific classes.
A very simple wrapper around a message id.
 
A physical connection to a data source, to be used for creating logical connections to the same data source.
 
PossibleTypes is information which is set of types.
 
 
 
 
 
 
 
This datasource is suitable for a client/server use of Derby, running on full Java SE 6 and higher, corresponding to JDBC 4.0 and higher.
Deprecated.
Use ClientXADataSource instead.
Specifies Derby extensions to the java.sqlx.XADataSource.
 
Wrap a Writer as an OutputStream to support Clob.setAsciiStream().
An InputStream that will use an locator to fetch the Clob value from the server.
An OutputStream that will use an locator to write bytes to the Clob value on the server.
An Reader that will use an locator to fetch the Clob value from the server.
An Writer that will use an locator to write the Clob value into the server.
 
Generates stream headers for Clob data values.
This class implements TypeCompiler for the SQL LOB types.
ClobUpdatableReader is used to create a Reader capable of detecting changes to the underlying source.
Writer implementation for Clob.
 
Implementation of a replacement policy which uses the clock algorithm.
This is a simple interface that is used by streams that can clone themselves.
 
A stream that will throw an exception if its methods are invoked after it has been closed.
This node represents coalesce/value function which returns the first argument that is not null.
This class represents a chunk of code in a CodeAttribute.
This is a simple interface that houses externally visible statics for code generation.
 
 
 
This class has a hashtable of CodePoint values.
CollationElementsInterface is an interface which will be implemented by all the Collator sensitive char data types.
CollatorSQLChar class differs from SQLChar based on how the 2 classes use different collations to collate their data.
CollatorSQLClob class differs from SQLClob based on how the 2 classes use different collations to collate their data.
CollatorSQLLongvarchar class differs from SQLLongvarchar based on how the 2 classes use different collations to collate their data.
CollatorSQLVarchar class differs from SQLVarchar based on how the 2 classes use different collations to collate their data.
Collect all nodes of the designated type to be returned in a list.
This class describes a row in the SYS.SYSCOLPERMS system table, which keeps the column permissions that have been granted but not revoked.
A ColumnDefinitionNode represents a column definition in a DDL statement.
This class represents a column descriptor.
This represents a list of column descriptors.
This class provides supportto create casting/conversions required to perform import.
This is the Column descriptor that is passed from Compilation to Execution for CREATE TABLE statements.
 
The column ordering interface defines a column that is to be ordered in a sort or index, and how it is to be ordered.
 
A ColumnReference represents a column in the query tree.
Helper class to keep track of remap data when a ColumnReference is remapped multiple times.
 
This interface must be implemented by objects returned from LockFactory.createCompatibilitySpace().
A Compensation operation can compensate for the action of a log operation.
CompilerContext stores the parser and type id factory to be used by the compiler.
CompilerContextImpl, implementation of CompilerContext.
Static methods to write and read compressed forms of numbers to DataOut and DataIn interfaces.
Log operation to implement compressing space from a container and returning it to the operating system.
This class overrides the CompressSpacePageOperation class to write CompressSpaceOperation Log Records that do not support negative values for new_highest_page.
The ConcatableDataValue interface corresponds to the SQL 92 string value data type.
This node represents a concatenation comparison operator varying.
A cache manager based on the utilities found in the java.util.concurrent package.
Factory class which creates cache manager instances based on the ConcurrentCache implementation.
This class provides monitoring capabilities for ConcurrentCache through Java Management Extension (JMX).
A ConcurrentLockSet is a complete lock table which maps Lockables to LockControl objects.
Class representing an entry in the lock table.
A LockFactory which allows multiple threads to enter without blocking each other out.
A Conditional represents an if/then/else block.
A ConditionalNode represents an if/then/else operator with a single boolean expression on the "left" of the operator and a list of expressions on the "right".
 
A conglomerate is an abstract storage structure (they correspond to access methods).
A conglomerate is an abstract storage structure (they correspond to access methods).
The ConglomerateDescriptor class is used to get information about conglomerates for the purpose of optimization.
 
The factory interface for all conglomerate access methods.
Static utility routine package for all Conglomerates.
 
ConglomPropertyable provides the interfaces to read properties from a conglomerate.
 
Any class in the embedded JDBC driver (ie this package) that needs to refer back to the EmbedConnection object extends this class.
Interface-ized from EmbedConnectionContext.
To enable multi-user use of ij.Main2
 
 
 
 
This interface describes the columns in a referenced constraint.
The ConsistencyChecker class provides static methods for verifying the consistency of the data stored within a database.
Class which represents an RDB Package Consistency Token.
Double Constant - page 97 - Section 4.4.5
Float Constant - page 96
A generic constant pool entry for entries that simply hold indexes into other entries.
Integer Constant - page 96
Long Constant - page 97 - Section 4.4.5
Utf8- page 100 - Section 4.4.7
This interface describes actions that are ALWAYS performed for a Statement at Execution time.
A pre-compiled activation that supports a single ResultSet with a single constant action.
This visitor replaces a ValueNode with a node representing a constant value, if the ValueNode is known to always evaluate to the same value.
ConstantNode holds literal constants as well as nulls.
Constant Pool class - pages 92-99
 
This class describes actions that are ALWAYS performed for a constraint creation at Execution time.
A ConstraintDefintionNode is a class for all nodes that can represent constraint definitions.
This class is used to get information from a ConstraintDescriptor.
 
This is a simple class used to store the run time information about a constraint.
Contained roles shows all roles contained in the given identifier, or if the second argument, if given, is not 0, the inverse relation; all roles who contain the given role identifier.
An Observer that can be attached to a transaction to implement some action when the transaction commits or rollsback in some way.
A Container Operation change the state of the container.
A Container contains a contigious address space of pages, the pages start at page number Container.FIRST_PAGE_NUMBER and are numbered sequentially.
An abstract class that opens the container at commit and delegates the actual work to a sub-class.
A key that identifies a Container within the RawStore.
A ContainerLock represents a qualifier that is to be used when locking a container through a ContainerHandle.
A locking policy that implements container level locking with isolation degree 2.
A locking policy that implements container level locking with isolation degree 3.
Log operation to create, drop or remove a container.
A Container undo operation rolls back the change of a Container operation
Contexts are created and used to manage the execution environment.
 
Contexts are created and used to manage the execution environment.
The ContextManager collects contexts as they are created.
The CtxStack implement a stack on top of an ArrayList (to avoid the inherent overhead associated with java.util.Stack which is built on top of java.util.Vector, which is fully synchronized).
A set of static methods to supply easier access to contexts.
Specialized stack class that contains context managers.
 
 
Base class for leaf and branch control rows.
Represents copying num_rows from one page to another page.
FormatableInstanceGetter to load stored instances of DependableFinder.
 
A CostEstimate represents the cost of getting a ResultSet, along with the ordering of rows in the ResultSet, and the estimated number of rows in this ResultSet.
 
Definition for the COUNT()/COUNT(*) aggregates.
Aggregator for COUNT()/COUNT(*).
An OutputStream that simply provides methods to count the number of bytes written to an underlying stream.
This class provides a class path based implementation of the StorageFile interface.
This class provides a class path based implementation of the StorageFactory interface.
This class performs actions that are ALWAYS performed for a CREATE FUNCTION, PROCEDURE or SYNONYM Statement at execution time.
A CreateAliasNode represents a CREATE ALIAS statement.
This class describes actions that are ALWAYS performed for a constraint creation at Execution time.
This class is used by PlanExporter tool (DERBY-4587) in order to create HTML output of a query plan using a plain XSL style sheet and a XML data of a query plan.
ConstantAction to create an index either through a CREATE INDEX statement or as a backing index to a constraint.
A CreateIndexNode is the root of a QueryTree that represents a CREATE INDEX statement.
This class performs actions that are ALWAYS performed for a CREATE ROLE statement at execution time.
A CreateRoleNode is the root of a QueryTree that represents a CREATE ROLE statement.
This class describes actions that are ALWAYS performed for a CREATE SCHEMA Statement at Execution time.
A CreateSchemaNode is the root of a QueryTree that represents a CREATE SCHEMA statement.
This class performs actions that are ALWAYS performed for a CREATE SEQUENCE statement at execution time.
A CreateSequenceNode is the root of a QueryTree that represents a CREATE SEQUENCE statement.
This class describes actions that are ALWAYS performed for a CREATE TABLE Statement at Execution time.
A CreateTableNode is the root of a QueryTree that represents a CREATE TABLE or DECLARE GLOBAL TEMPORARY TABLE statement.
This class describes actions that are ALWAYS performed for a CREATE TRIGGER Statement at Execution time.
A CreateTriggerNode is the root of a QueryTree that represents a CREATE TRIGGER statement.
This class describes actions that are ALWAYS performed for a CREATE VIEW Statement at Execution time.
A CreateViewNode is the root of a QueryTree that represents a CREATE VIEW statement.
This class is to create the final xml file, that will be used by the Graphical Query Explainer.
 
CurrentDatetime provides execution support for ensuring that the current datetime is evaluated only once for a statement.
The CurrentDatetimeOperator operator is for the builtin CURRENT_DATE, CURRENT_TIME, and CURRENT_TIMESTAMP operations.
The CurrentOf operator is used by positioned DELETE and UPDATE to get the current row and location for the target cursor.
Takes a cursor name and returns the current row of the cursor; for use in generating the source row and row location for positioned update/delete operations.
The CurrentRowLocation operator is used by DELETE and UPDATE to get the RowLocation of the current row for the target table.
 
CursorActivation includes an additional method used on cursors.
In the family of activation support classes, this one provides an activation with a cursor name.
A basic holder for information about cursors for execution.
A CursorNode represents a result set that can be returned to a client.
The CursorResultSet interface is used to provide additional operations on result sets that can be used in cursors.
 
Debugging class used to print debug information about a B2I.
The D_BaseContainerHandle class provides diagnostic information about the BaseContainerHandle class.
Validate BC calls.
 
The D_BaseContainerHandle class provides diagnostic information about the BaseContainerHandle class.
The D_ContainerLock class provides diagnostic information about the ContainerLock qualifer, and is used for output in lock debugging.
This class provides some utility functions used to debug on disk structures of the store.
 
 
 
 
The D_RecordId class provides diagnostic information about the BaseContainerHandle class.
The D_RowLock class provides diagnostic information about the RowLock qualifer, and is used for output in lock debugging.
The D_StoredPage class provides diagnostic information about the StoredPage class.
The D_Xact class provides diagnostic information about the Xact class.
Daemon Factory can create new DaemonService, which runs on seperate background threads.
A DaemonService provides a background service which is suitable for asynchronous I/O and general clean up.
The Database interface provides control over a database (that is, the stored data and the files the data are stored in), operations on the database such as backup and recovery, and all other things that are associated with the database itself.
The org.apache.derby.iapi.db.Database interface provides "internal" methods on the database which are not available to JBMS users (org.apache.derby.database.Database, which this interface extends, provides all the externally visible methods).
Database stores information about the current database It is used so that a session may have more than one database
An abstract implementation of the ClassFactory.
A context for a database.
A context that shutdowns down the database on a databsae exception.
A DatabaseInstant is a quantity which the database associates with events to collate them.
This class represents access to database-scoped privileges.
This is an implementation of the DataDescriptorGenerator interface that lives in the DataDictionary protocol.
The DataDictionary interface is used with the data dictionary to get descriptors for binding and compilation.
Standard database implementation of the data dictionary that stores the information in the system catalogs.
 
A util class for DataInput.
A virtual data store, keeping track of all the virtual files existing and offering a set of high-level operations on virtual files.
A data store entry representing either a file or a directory.
DataType is the superclass for all data types.
DataTypeDescriptor describes a runtime SQL type.
A set of static utility methods for data types.
The DataValueDescriptor interface provides methods to get the data from a column returned by a statement.
This interface is how we get data values of different types.
Core implementation of DataValueFactory.
High performance converters from date/time byte encodings to JDBC Date, Time and Timestamp objects.
 
This class provides a simple regular expression parser for standard format dates, times, and timestamps
This class represents a date or time value as it is represented in the database.
 
 
 
 
 
 
 
 
 
Dblook implementation for SEQUENCEs.
 
 
 
This node represents a unary DB2 compatible length operator
 
OptionalTool to create wrapper functions which allow you to invoke DatabaseMetaData methods via SQL.
Generic code for upgrading data dictionaries.
Class for implementation of DependableFinder in the core DataDictionary for referenced columns in a table.
Class for most DependableFinders in the core DataDictionary.
Abstract class that has actions that are across all DDL actions.
Mutable Boolean wrapper, initially false
Abstract class that has actions that are across all DDL actions that are tied to a table.
A DDLStatementNode represents any type of DDL statement: CREATE TABLE, CREATE INDEX, ALTER TABLE, etc.
The DDMReader is used to read DRDA protocol.
The DDMWriter is used to write DRDA protocol.
Static Data dictionary utilities.
Code to support deadlock detection.
 
Converters from fixed point decimal bytes to java.math.BigDecimal, double, or long.
 
A DecryptInputStream is used by stream container to access an encrypted stream of bytes.
This class is used to decrypt password and/or userid.
This interface is used to get information from a DefaultDescriptor.
An interface for describing a default for a column or parameter in Derby systems.
 
DefaultNode represents a column/parameter default.
This is the default optimizer tracing logic for use when a custom tracer wasn't specified.
This class implements the default policy for defering modifications to virtual tables.
This interface is implemented by a read/write VTI class that wants to control when modifications to the VTI are deferred, or to be notified that a it is to be modified.
This class provides support for deferrable constraints.
Info needed for check constraints
 
Info needed for unique and primary key constraints
Class hierarchy carrying the information we need to validate some deferred constraint.
Delete the rows from the specified base table and executes delete/update on dependent tables depending on the referential actions specified.
This class describes compiled constants that are passed into DeleteResultSets.
A DeleteNode represents a DELETE statement.
Represents a delete (or undelete) of a record in a page.
Delete the rows from the specified base table.
Delete the rows from the specified base table.
 
A Dependable is an in-memory representation of an object managed by the Dependency System.
A DependableFinder is an object that can find an in-memory Dependable, given the Dependable's ID.
A dependency represents a reliance of the dependent on the provider for some information the dependent contains or uses.
DependencyDescriptor represents a persistent dependency between SQL objects, such as a TRIGGER being dependent on a TABLE.
Dependency Manager Interface
A dependent has the ability to know whether or not it is valid and to mark itself as valid or invalid.
DependentResultSet should be used by only ON DELETE CASCADE/ON DELETE SET NULL ref actions implementation to gather the rows from the dependent tables.
A subclass of IOException that carries a SQL state.
Created to provide the Observable behavior which Derby has depended on since Java 1.2 but which as deprecated in JDK 9 build 118.
Created to provide the Observable behavior which Derby has depended on since Java 1.2 but which as deprecated in JDK 9 build 118.
 
 
The Diagnosticable class implements the Diagnostics protocol, and can be used as the parent class for all other Diagnosticable objects.
The Diagnosticable class implements the Diagnostics protocol, and can be used as the parent class for all other Diagnosticable objects.
 
Utility methods for the package of diagnostic vtis.
 
 
 
This class provides a disk based implementation of the StorageFile interface.
This class provides a disk based implementation of the StIRandomAccess File interface.
This class provides a disk based implementation of the StorageFactory interface.
 
This class is used by BackingStoreHashtable when the BackingStoreHashtable must spill to disk.
This ResultSet evaluates grouped aggregates when there is 1 or more distinct aggregate.
A DistinctNode represents a result set for a distinct operation on a select.
This ResultSet evaluates scalar aggregates where 1 (or more, in the future) of the aggregates are distinct.
Eliminates duplicates while scanning the underlying conglomerate.
A DMLModGeneratedColumnsStatementNode for a table(with identity columns) modification: to wit, INSERT, UPDATE.
A DMLStatement for a table modification: to wit, INSERT UPDATE or DELETE.
A DMLStatementNode represents any type of DML statement: a cursor declaration, an INSERT statement, and UPDATE statement, or a DELETE statement.
Base class for Insert, Delete and UpdateVTIResultSet
 
For INSERT/UPDATE/DELETE impls.
A properties object that links two independent properties together.
This class translates DRDA protocol from an application requester to JDBC for Derby and then translates the results from Derby to DRDA for return to the application requester.
 
 
 
 
DRDAResultSet holds result set information
Class that starts the network server in its own daemon thread.
Class used to transport that fact that we had a timeout and should *NOT* disconnect the connection.
DRDAStatement stores information about the statement being executed
This class is used to keep track of the statement's parameters as they are received from the client.
This class provides functionality for reusing buffers and strings when parsing DRDA packets.
This class translates DRDA XA protocol from an application requester to XA calls for Derby and then translates the results from Derby to DRDA for return to the application requester.
 
Embedded JDBC driver for JDBC 4.2.
This class performs actions that are ALWAYS performed for a DROP FUNCTION/PROCEDURE/SYNONYM statement at execution time.
A DropAliasNode represents a DROP ALIAS statement.
This class describes actions that are ALWAYS performed for a drop constraint at Execution time.
A Filter to qualify tuples coming from a scan of SYSDEPENDS.
This class describes actions that are ALWAYS performed for a DROP INDEX Statement at Execution time.
A DropIndexNode is the root of a QueryTree that represents a DROP INDEX statement.
Drop a table on a commit or abort
This class describes actions that are ALWAYS performed for a DROP ROLE Statement at Execution time.
A DropRoleNode is the root of a QueryTree that represents a DROP ROLE statement.
This class describes actions that are ALWAYS performed for a DROP SCHEMA Statement at Execution time.
A DropSchemaNode is the root of a QueryTree that represents a DROP SCHEMA statement.
This class describes actions that are ALWAYS performed for a DROP SEQUENCE Statement at Execution time.
A DropSequenceNode represents a DROP SEQUENCE statement.
this class drops all statistics for a particular table or index.
This class describes actions that are ALWAYS performed for a DROP TABLE Statement at Execution time.
A DropTableNode is the root of a QueryTree that represents a DROP TABLE statement.
This class describes actions that are ALWAYS performed for a DROP TRIGGER Statement at Execution time.
A DropTriggerNode is the root of a QueryTree that represents a DROP TRIGGER statement.
This class describes actions that are ALWAYS performed for a DROP VIEW Statement at Execution time.
A DropViewNode is the root of a QueryTree that represents a DROP VIEW statement.
 
This class defines DSS constants that are shared in the classes implementing the DRDA protocol.
 
 
A DynamicByteArrayOutputStream allows writing to a dynamically resizable array of bytes.
Information that can be "compiled" and reused per transaction per open operation.
A concrete implementation of a CcsidMgr used to convert between Java UCS2 and Ebcdic as needed to handle character DDM Parameters.
A concrete implementation of a CcsidMgr used to convert between Java UCS2 and Ebcdic as needed to handle character DDM Parameters.
Implements java.sql.Blob (see the JDBC 2.0 spec).
Local implementation.
 
Implements java.sql.Clob (see the JDBC 2.0 spec).
Local implementation of Connection for a JDBC driver in the same process as the database.
 
This class provides information about the database as a whole.
 
This datasource is suitable for an application using embedded Derby, running on full Java SE 6 and higher, corresponding to 4.0 and higher.
Deprecated.
Common interface of Derby embedded connection pooling data sources.
This data source is suitable for an application using embedded Derby, running on full Java SE 6 and higher, corresponding to 4.0 and higher.
Deprecated.
Use EmbeddedDataSource instead.
Methods that extend the API of javax.sql.DataSource common for all Derby embedded data sources.
The embedded JDBC driver (Type 4) for Derby.
This data source is suitable for an application using embedded Derby, running on full Java SE 6 or higher, corresponding to JDBC 4.0 and higher.
Deprecated.
Common interface of Derby embedded XA data sources.
This class implements the ParameterMetaData interface from JDBC 3.0.
A PooledConnection object is a connection object that provides hooks for connection pool management.
EmbedPreparedStatement is a local JDBC statement.
PreparedStatement methods added by JDBC 4.2 which require Java 8.
A EmbedResultSet for results from the EmbedStatement family.
JDBC 4.2 specific methods that cannot be implemented in superclasses.
A ResultSetMetaData object can be used to find out about the types and properties of the columns in a ResultSet.
This class implements the Savepoint interface from JDBC 3.0.
EmbedStatement is a local JDBC statement.
 
Implements XAResource
Create an encoded stream from a Reader.
Log operation to encrypt a container with a new encryption key or to encrypt an unencrypted container while configuring the database for encryption.
A Encrypt Container undo operation rolls back the change of a Encrypt Container operation
This class is a wrapper class on top of StorageRandomAccess to provide common methods to write in encrypted file.
 
This class is used to encrypt all the containers in the data segment with a new encryption key when password/key is changed or when an existing database is reconfigured for encryption.
This operation indicates the End of a transaction.
Additional methods the engine exposes on its CallableStatement object implementations, whose signatures are not compatible with older platforms.
Additional methods the embedded engine exposes on its Connection object implementations.
Additional methods the embedded engine exposes on all of its large object (LOB) implementations.
Additional methods the embedded engine exposes on its PreparedStatement object implementations.
Additional methods the embedded engine exposes on its ResultSet object implementations.
Additional methods the embedded engine exposes on its Statement object implementations.
Derby engine types.
Getting error information for SQLData/serializable data streams.
ErrorLogReader is a virtual table interface (VTI) which contains all the statements of "interest" in db2j.log or a specified file when db2j.language.logStatementText=true.
ErrorMessage shows all the SQLStates, locale-sensitive error messages, and exception severities for a database.
Limit and ObjectInput capabilities.
Class used to form error messages.
 
An exception factory is used to create SQLExceptions of the correct type.
 
This is a refactoring wrapper around the common ExceptionSeverity class and may be removed at some point in the future.
Severity constants for SQLExceptions.
This class provides utility routines for exceptions
This class provides utility routines for exceptions
An ExecAggregator is the interface that execution uses to an aggregate.
This is a table name reference that can be retrieved from an active cursor.
This is an extension of ExecRow for use with indexes and sorting.
Execution extends prepared statement to add methods it needs for execution purposes (that should not be on the Database API).
Execution sees this extension of Row that provides connectivity to the Storage row interface and additional methods for manipulating Rows in execution's ResultSets.
A class used for storing information on how to build ExecRow instances.
A ExecSPSNode is the root of a QueryTree that represents an EXECUTE STATEMENT statement.
ExecutionContext stores the factories that are to be used by the current connection.
This is the factory for creating a factories needed by execution per connection, and the context to hold them.
An ExecutionStatementValidator is an object that is handed a ConstantAction and asked whether it is ok for this result set to execute.
This class provides ways to export data from a table or a view into a file.
 
 
 
ExpressionClassBuilder provides an interface to satisfy generation's common tasks in building classes that involve expressions.
This is a simple interface to hide the impl of ExpressionClassBuilder from the protocol side.
EXTDTAObjectHolder provides Externalized Large Object representation that does not hold locks until the end of the transaction (DERBY-255) It serves as a holder for lob data and is only valid as long as the original result set from which it came is on the same row.
Implementation of InputStream which get EXTDTA from the DDMReader.
 
This node represents a unary extract operator, used to extract a field from a date/time.
Callers of these methods must be within the context of a Derby statement execution otherwise a SQLException will be thrown.
Class FailedProperties40 is a helper class for java.sql.SQLClientInfoException.
Class FailedProperties40 is a helper class for the SQLClientInfoException.
A stream class that throws an exception on the first read request.
 
 
 
FetchDescriptor is used to package up all the arguments necessary to describe what rows and what row parts should be returned from the store back to language as part of a fetch.
FileContainer is an abstract base class for containers which are based on files.
A Descriptor for a file that has been stored in the database.
Write log records to a log file as a stream (ie. log records added to the end of the file, no concept of pages).
Implementation of the monitor that uses the class loader that the its was loaded in for all class loading.
Management of file resources within a database.
A set of public static methods for dealing with File objects.
A FKConstraintDefintionNode represents table constraint definitions.
This is a simple class used to store the run time information about a foreign key.
Converters from floating point bytes to Java float, double, or java.math.BigDecimal.
Scan the the log which is implemented by a series of log files.n This log scan knows how to move across log file if it is positioned at the boundary of a log file and needs to getNextRecord.
 
OptionalTool to create wrapper functions and views for all of the user tables in a foreign database.
A foreign key.
A Referential Integrity checker for a foreign key constraint.
This class contains a table function which can be used to bulk-import data from a foreign database.
Derby interface for creating a stored form for an object and re-constructing an equivalent object from this stored form.
A formatable holder for an array of formatables.
FormatableBitSet is implemented as a packed array of bytes.
A formatable holder for a java.util.Hashtable.
Class that loads Formattables (typically from disk)through one level of indirection.
A formatable holder for an int.
A formatable holder for an long.
A formatable holder for a java.util.Properties.
A stream for reading objects with format id tags which was produced by a FormatIdOutputStream.
A stream for serializing objects with format id tags.
Utility class with static methods for constructing and reading the byte array representation of format id's.
This class contains a table function which forwards its behavior to another ResultSet wrapped inside it.
A FromBaseTable represents a table in the FROM list of a DML statement, as distinguished from a FromSubquery, which represents a subquery in the FROM list.
A FromList represents the list of tables in a FROM clause in a DML statement.
A FromSubquery represents a subquery in the FROM list of a DML statement.
A FromTable represents a table in the FROM clause of a DML statement.
A FromVTI represents a VTI in the FROM list of a DML statement.
This is a common superclass for the various impls.
Generated classes must implement this interface.
A meta-class that represents a generated class.
Handle for a method within a generated class.
This node describes a Generation Clause in a column definition.
This class holds an Activation, and passes through most of the calls to the activation.
Generic aggregation utilities.
Adaptor that sits between execution layer and aggregates.
 
This is a stripped down implementation of a column descriptor that is intended for generic use.
A class that implements the methods shared across all implementations of the Conglomerate interface.
 
Factory for creating ConstantActions.
 
A Generic class which implements the basic functionality needed for a cost controller.
 
ExecutionContext stores the result set factory to be used by the current connection, and manages execution-level connection activities.
This Factory is for creating the execution items needed by a connection for a given database.
LanguageConnectionContext keeps the pool of prepared statements, activations, and cursors in use by the current connection.
LanguageConnectionFactory generates all of the items a language system needs that is specific to a particular connection.
The LanguageFactory provides system-wide services that are available on the Database API.
A parameter.
Implementation of ParameterValueSet
Basic implementation of prepared statement.
This class holds information about stale plan check interval, execution count and row count statistics for a GenericPreparedStatement.
 
This is the implementation for Qualifier.
GenericResultDescription: basic implementation of result description, used in conjunction with the other implementations in this package.
ResultSetFactory provides a wrapper around all of the result sets used in this execution implementation.
Generic implementation of a Referential Integrity checker.
The set of interfaces implemented by all types of ScanControllers.
Generic class implementing shared ScanController methods.
This is the implementation for ScanQualifier.
 
GenericStatementContext is pushed/popped around a statement prepare and execute so that any statement specific clean up can be performed.
This is a TimerTask that is responsible for timing out statements, typically when an application has called Statement.setQueryTimeout().
Prepared statement that can be made persistent.
A trigger executor is an object that executes a trigger.
This node represents a unary getCurrentConnection operator RESOLVE - parameter will always be null for now.
Use of VirtualTableInterface to provide support for DatabaseMetaData.getProcedureColumns().
A transaction identifier that is unique among all raw stores and all transactions The equals() method for TransactionId implements by value equality.
This abstract class represents a global transaction id which can be tested for equality against other transaction ids, which can be hashed into a hash table, and which can be output as a string.
 
This class represents a GRANT statement.
 
This class performs actions that are ALWAYS performed for a GRANT role statement at execution time.
This class represents a GRANT role statement.
A GroupByColumn is a column in the GROUP BY clause.
A GroupByList represents the list of expressions in a GROUP BY clause in a SELECT statement.
A GroupByNode represents a result set for a grouping operation on a select.
Comparator class for GROUP BY expression substitution.
This ResultSet evaluates grouped, non distinct aggregates.
This scan controller can only be used for group fetch, no update operations are supported, use ScanController if you need scan interfaces other than group fetch.
An HalfOuterJoinNode represents a left or a right outer join result set.
Copied from the Harmony project's implementation of javax.sql.rowset.serial.SerialBlob at subversion revision 946981.
Copied from the Harmony project's implementation of javax.sql.rowset.serial.SerialClob at subversion revision 946981.
Find out if we have an correlated column reference anywhere below us.
Hash join of 2 arbitrary result sets.
 
Left outer join using hash join of 2 arbitrary result sets.
Takes a conglomerate and a table filter builds a hash table on the specified column of the conglomerate on the 1st open.
A HashTableNode represents a result set where a hash table is built.
Builds a hash table on the underlying result set tree.
Find out if we have a particular node anywhere in the tree.
Find out if we have a user-defined table function anywhere in the tree.
Find out if we have a value node with variant type less than what the caller desires, anywhere below us.
A HeaderPrintWriter is like a PrintWriter with support for including a header in the output.
A heap object corresponds to an instance of a heap conglomerate.
 
 
A heap scan object represents an instance of a scan on a heap conglomerate.
The heap conglomerate factory manages heap conglomerates implemented on the raw store.
 
The StoreCostController interface provides methods that an access client (most likely the system optimizer) can use to get store's estimated cost of various operations on the conglomerate the StoreCostController was opened for.
The HeapPostCommit class implements the Serviceable protocol.
A heap row location represents the location of a row in the heap.
 
This object provides performance information related to an open scan.
Utility class for parsing and producing string representations of ids.
An internal api for VTIs to allow VTI's written in terms of the datatype system, e.g. returning rows.
Filter which fails all Visitables.
ij is Derby's interactive JDBC scripting tool.
 
ijException is used to get messages from the ij parser to the main ij loop.
This is an impl for just returning errors from JDBC statements.
Used for fatal IJ exceptions
This impl is intended to be used with multiple resultsets, where the execution of the statement is already complete.
This is an impl for a statement execution; the result is either an update count or result set depending on what was executed.
This is a wrapper for results coming out of the ij parser.
This is an empty impl for reuse of code.
This impl is intended to be used with a resultset, where the execution of the statement is already complete.
This is an impl for when 1 row of a result set is the intended use of it.
This is an impl for a statement execution; the result is either an update count or result set depending on what was executed.
 
This is an impl for a simple Vector of objects.
This is an impl for just returning warnings from JDBC objects we don't want the caller to touch.
 
This class implements import of data from a URL into a table.
This class implements java.sql.BLOB interface .
This class implements java.sql.CLOB interface .
An InputStream, which can stream data from a file, starting from any offset in the file.
Helper class to read large object data at random locations from a file that contains large object data.
 
 
Perform Index maintenance associated with DML operations for a single index.
Basic implementation of ColumnOrdering.
This class is the superclass for the classes that describe actions that are ALWAYS performed for a CREATE/DROP INDEX Statement at Execution time.
This interface describes an index.
A poor mans structure used in DataDictionaryImpl.java.
This interface gathers up some tasty information about the indices on a table from the DataDictionary.
Basic implementation of ExecIndexRow.
This class extends IndexDescriptor for internal use by the DataDictionary.
Takes a result set with a RowLocation as the last column, and uses the RowLocation to get and return a row from the given base conglomerate.
Perform Index maintenace associated with DML operations for a table's indexes.
Daemon acting as a coordinator for creating and updating index statistics.
Daemon acting as a coordinator for creating and updating index cardinality statistics.
Support class used to compare keys when scanning indexes.
This node type translates an index row to a base row.
Mapper of ValueRow into ExecIndexRow.
The Basic Services provide InfoStreams for reporting information.
This operation initializes the page that is being allocated, this operation does not change the alloc page information.
An InListOperatorNode represents an IN list.
A class that uses a ZipEntry to be a single container file, but read-only.
This class provides the base for read-only stream implementations of the StorageFile interface.
Utility methods for InputStream that are stand-ins for a small subset of DataInput methods.
This class describes compiled constants that are passed into InsertResultSets.
An InsertNode is the top node in a query tree for an insert statement.
Represents an insert of a record onto a page.
Insert the rows from the source into the specified base table.
Insert the rows from the source into the specified base table.
 
A set of operations available on internal Clob content representations.
Factory class and API for JDBC objects.
Thread factory to produce daemon threads which don't block VM shutdown.
This code is called in a thread which puts time limits on it.
There is one of these beasts per INSERT/DELETE/UPDATE statement.
 
An exception used to pass a specific "error code" through various layers of software.
Static methods to save and retrieve information about a (session) thread's interrupt status flag.
A IntersectOrExceptNode represents an INTERSECT or EXCEPT DML statement.
Represents invalidating a page due to deallocation.
 
 
This node represents either a unary IS NULL or IS NOT NULL comparison operator
This class provides a jar file based implementation of the StorageFile interface.
 
Abstract out the loading of JarFiles.
This class provides a Jar file based implementation of the StorageFactory interface.
 
System procedures which run only on Java 5 or higher.
JavaFactory provides generators for Java constructs.
This node type converts a value from the Java domain to the SQL domain.
This abstract node class represents a data value in the Java domain.
JBitSet is a wrapper class for BitSet.
This CipherFactory creates new JCECipherProvider.
 
Cipher Factory instance builder.
This is a wrapper for a Cipher
Simple JBDC mbean that pulls information about the JDBC driver.
This class is a refactoring wrapper around the shared JDBC40Translation class.
This class contains public statics that map directly to the new public statics in the jdbc 4.0 interfaces.
A class to boot a Derby system that includes a JDBC driver.
This class contains utility methods for displaying JDBC objects and results.
Management and information for the embedded JDBC driver.
A cache for JDBC statement objects.
A LinkedHashMap with an upper bound on the number of entries.
This class implements the ManagementService interface and provides a simple management and monitoring service.
This is the base JNDI authentication scheme class.
This is the JNDI Authentication Service base class.
A JoinNode represents a join result set for either of the basic DML operations: SELECT and INSERT.
Takes 2 NoPutResultSets and a join filter and returns the join's rows satisfying the filter as a result set.
A JoinStrategy represents a strategy like nested loop, hash join, merge join, etc.
Type descriptor which wraps all 3 kinds of types supported in Derby's JSQL language: SQL types, Java primitives, Java classes.
This class is used to determine which Java specification Derby will run at.
This interface is used to get information from a KeyConstraintDescriptor.
Provides the ability to hash on multiple objects.
LanguageConnectionContext keeps the result sets, and activations in use by the current connection.
Factory interface for items specific to a connection in the language system.
A class to handle setting language database properties
Factory interface for the Language.Interface protocol.
This is a holder of language properties that are exposed users.
Return the last key in an index.
A Latch represents a latch held in the lock manager.
Implementation of InputStream which get EXTDTA from the DDMReader.
This is the Derby LDAP authentication scheme implementation.
 
This node represents a unary XXX_length operator
A BTreeDiag class is a "helper" class for the rest of the btree generic code.
Like matching algorithm.
This node represents a like comparison operator (no escape) If the like pattern is a constant or a parameter then if possible the like is modified to include a >= and < operator.
Methods that allow limits to be placed on an input or output stream to avoid clients reading or writing too much information.
A limit represents a callback on a lock group.
An abstract InputStream that provides abstract methods to limit the range that can be read from the stream.
Limit and ErrorObjectInput capabilities.
A Reader that provides methods to limit the range that can be read from the reader.
 
 
These exceptions are thrown by the import and export modules.
 
LOBFile is a wrapper over StorageRandomAccessFile.
This input stream is built on top of LOBStreamControl.
This is an output stream built on top of LOBStreamControl.
An object that tracks the state of large objects (LOBs) for the current row in a result set.
Contains the stored procedures that will be used in the LOB client side methods.
This class acts as a layer of blob/clob repository (in memory or file).
This class implements TypeCompiler for the SQL LOB types.
A LocaleFinder gets a Locale and things associated with Locales.
A field within the generated class.
 
 
 
Mutable holder for the column values and RowLocation of a conglomerate row.
A Lock represents a granted or waiting lock request.
Any object that needs to be locked must implement Lockable.
A LockControl contains a reference to the item being locked and doubly linked lists for the granted locks and the waiting locks.
 
Generic locking of objects.
Any object that implements this interface can be used as a locking policy for accessing a container.
An Enumeration that returns the the Lockables in a group.
Interface for classes that represent an owner of the locks within a compatibility space.
A LockSpace represents the complete set of locks held within a single compatibility space, broken into groups of locks.
LockTable is a virtual table that shows all locks currently held in the database.
Interface which must be implemented by lock table classes.
This class describes actions that are ALWAYS performed for a LOCK TABLE Statement at Execution time.
A LockTableNode is the root of a QueryTree that represents a LOCK TABLE command: LOCK TABLE IN SHARE/EXCLUSIVE MODE
This provides an Enumeration of Latch's from a clone of the lock table.
Wraps a RandomAccessFile file to provide buffering on log writes.
A single buffer of data.
ReplicationLogBuffer consists of n LogBufferElements, each of which can store a number of log records in a single byte[].
 
A very simple log instant implementation.
 
A Loggable is a record of a change of state or an event that happened in the RawStore in the context of a transaction.
 
 
 
A wrapper class for a physical Derby callable statement.
JDBC 4 specific wrapper class for a Derby physical callable statement.
A simple delegation wrapper handle for a physical connection.
A metadata object to be used with logical connections when connection pooling is being used.
An abstract class that is used for logical log operation.
A wrapper class for a physical Derby prepared statement.
JDBC 4.2 specific wrapper class for a Derby physical prepared statement.
Common class interacting with the JDBC statement cache for logical prepared statements and logical callable statements.
A Logical undo is an undo operation that operates on a different page from the page that has the original change.
A LogicalUndoable is a log operation that operates on the content of a page and the log operation needs logical undo.
LogicalUndoOperation is a compensation operation that rolls back the change of an LogicalUndoable operation.
Describes a position in the log.
The log record written out to disk.
 
LogScan provides methods to read a log record from the log.
This is the interface for the replication log shipper.
This is an implementation of the log using a non-circular file system file.
 
An exception used to pass a specfic "error code" through various layers of software.
Methods to aid classes recover from OutOfMemoryErrors by denying or reducing service rather than a complete shutdown of the JVM.
This is the controller for ij.
Sysinfo reports values relevant to the current Derby configuration.
Management MBean to allow applications to dynamically control visibility of Derby's MBeans.
JMX MBean inteface to control visibility of Derby's MBeans.
This interface represents a Management Service.
This is an implementation of the replication master controller service.
This is the interface for the replication master controller service.
Provides the ability for an object to match a subset of a group of other objects.
Describes the execution machinery needed to evaluate a WHEN [ NOT ] MATCHING clause of a MERGE statement.
Node representing a WHEN MATCHED or WHEN NOT MATCHED clause in a MERGE statement.
Materialize the underlying ResultSet tree into a temp table on the 1st open.
A MaterializeResultSetNode represents a materialization result set for any child result set that needs one.
A MaterializeSubqueryNode is used to replace the nodes for a subquery, to facilitate code generation for materialization if possible.
 
 
Defintion for the MAX()/MIN() aggregates.
Aggregator for MAX()/MIN().
 
 
A ByteHolder that stores all its bytes in memory.
 
Describes the execution machinery needed to evaluate a MERGE statement.
 
Merge two result sets.
A MergeNode represents a MERGE statement.
INSERT/UPDATE/DELETE a target table based on how it outer joins with a driving table.
A sort scan that is capable of merging as many merge runs as will fit in the passed-in sort buffer.
Wrapping the output of a MergeScan in a RowSource for the benefit of the createAndLoadConglomerate and loadConglomerate interface.
A sort implementation which does the sort in-memory if it can, but which can do an external merge sort so that it can sort an arbitrary number of rows.
This object provides performance information related to a sort.
This class is a refactoring wrapper around the new location in shared/common/reference
This class contains message identifiers for strings that are not converted to SQL exceptions.
Message Service implementation provides a mechanism for locating messages and substituting arguments for message parameters.
Class comments here
 
Describe a method alias.
MethodBuilder is used to generate the code for a method.
A MethodCallNode represents a Java method call.
The interface of all access method factories.
A MiscellaneousStatement represents any type of statement that doesn't fit into the well defined categories: SET (non-transaction).
This is a wrapper class which invokes the Execution-time logic for Misc statements.
A ModifyColumnNode represents a modify column in an ALTER TABLE statement.
 
ModuleControl is optionally implemented by a module's factory class.
The monitor provides a central registry for all modules in the system, and manages loading, starting, and finding them.
A description of an instance of a module.
Allows a module to check its environment before it is selected as an implementation.
Services
A service is a collection of modules that combine to provide the full functionality defined by the service.
 
mtTester grabs test and runs them forever.
 
 
Result set that fetches rows from a scan by "probing" the underlying table with a given list of values.
This is a naive trust manager we use when we don't want server authentication.
This is a naive trust manager we use when we don't want server authentication.
This class implements a Cacheable for a DataDictionary cache of table descriptors, with the lookup key being the name of the table.
This authentication service supports Derby NATIVE authentication.
Takes 2 NoPutResultSets and a join filter and returns the join's rows satisfying the filter as a result set.
 
Takes 2 NoPutResultSets and a join filter and returns the join's rows satisfying the filter as a result set plus the rows from the left joined with a null row from the right when there is no matching row in the right result set.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This servlet can be used to start Derby Network Server from a remote location.
 
 
 
 
 
NetworkServerControl provides the ability to start a Network Server or connect to a running Network Server to shutdown, configure or retrieve diagnostic information.
NetworkServerControlImpl does all the work for NetworkServerControl
This is an MBean defining a JMX management and monitoring interface of Derby's Network Server.
This is an implementation of the org.apache.derby.mbeans.drda.NetworkServerMBean, providing management and monitoring capabilities related to the Network Server through JMX.
 
 
 
 
 
A NewInvocationNode represents a new object() invocation.
A class that represents a value obtained from a Sequence using 'NEXT VALUE'
A node in a balanced binary tree.
NodeAllocator manages an array of nodes which can be reused.
A locking policy that implements no locking.
Dummy management service for environments that do not support JMX, such as Java SE compact profile 2.
This authentication service does not care much about authentication.
A NonStaticMethodCallNode is really a node to represent a (static or non-static) method call from an object (as opposed to a static method call from a class.
A NOPStatement node is for statements that don't do anything.
The NoPutResultSet interface is used to provide additional operations on result sets that can be used in returning rows up a ResultSet tree.
Abstract ResultSet with built in Activation support for operations that return rows but do not allow the caller to put data on output pipes.
Cast the rows from the source result set to match the format of the result set for the entire statement.
A NormalizeResultSetNode represents a normalization result set for any child result set that needs one.
Abstract ResultSet for implementations that do not return rows.
An exception used to pass a specfic "error code" through various layers of software.
A NotNode represents a NOT operator.
An OutputStream that simply discards all data written to it.
NumberDataType is the superclass for all exact and approximate numeric data types.
 
 
This class implements TypeId for the SQL numeric datatype.
Get all nodes of a certain type in a query tree, and return them in the order in which they appear in the original SQL text.
This class implements a Cacheable for a DataDictionary cache of table descriptors, with the lookup key being the UUID of the table.
Class to simply read the old format written by DataTypeDescriptor prior to DERBY-2775 being addressed.
Takes an expression subquery's result set and verifies that only a single scalar value is being returned.
This contains mnemonics for all of the opcodes of the JVM.
An open b-tree contains fields and methods common to scans and controllers.
A Generic class which implements the basic functionality needed to operate on an "open" conglomerate.
A utility class to store and use temporary scratch space associated with a conglomerate.
 
 
Provides an interface for an operator that operates on a range of objects E.g in a cache.
Abstract base-class for the various operator nodes: UnaryOperatorNode, BinaryOperatorNode and TernarnyOperatorNode.
Optimizable provides services for optimizing a table in a query.
OptimizableList provides services for optimizing a list of Optimizables (tables) in a query.
OptimizablePredicate provides services for optimizing predicates in a query.
OptimizablePredicateList provides services for optimizing a table in a query.
Optimizer provides services for optimizing a query.
This is simply the factory for creating an optimizer.
This is simply the factory for creating an optimizer.
Optimizer uses OptimizableList to keep track of the best join order as it builds it.
High level description of a plan for consideration by the Optimizer.
 
Generic plan for row sources we don't understand
 
 
 
This class provides static methods for controlling the optimizer tracing in a Derby database.
OptionalTool for tracing the Optimizer.
Interface implemented by optional tools which can be loaded and unloaded.
Interface for optimizer tracing.
OptionalTool for viewing the output created when you xml-trace the optimizer.
The Orderable interface represents a value that can be linearly ordered.
Abstract aggregator for Orderable aggregates (max/min).
An OrderByColumn is a column in the ORDER BY clause.
An OrderByList is an ordered list of columns in the ORDER BY clause.
An OrderByNode represents a result set for a sort operation for an order by list.
An ordered column has position.
List of OrderedColumns
 
 
A OverflowInputStream is used by store to turn a long column into an InputStream.
A Page contains an ordered set of records which are the stored form of rows.
 
A PageBasicOperation changed the content of a page, this is the root class of all page oriented operation.
This class holds information that is passed to CachedPage.createPage() and used when a page object (either a StoredPage or an AllocPage) is created.
A key that identifies a BasePage.
The type definition of a time stamp that can be associated with pages that supports 'time stamp'.
A per page version number is one way to implement a page time stamp
This node type represents a ?
A ParameterValueSet is a set of parameter values that can be assembled by a JDBC driver and passed to a PreparedStatement all at once.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
The Parser interface is intended to work with Jack-generated parsers (now JavaCC).
 
Unchecked exception class that can be used to pass checked exceptions out of methods that are not declared to throw any checked exception.
This machine performs the hashing of Derby passwords.
Helper methods to deal with paths in the in-memory "file system".
 
 
This class describes rows in the SYS.SYSPERMS system table, which keeps track of the permissions that have been granted but not revoked.
This class implements a Cacheable for a DataDictionary cache of permissions.
 
This class is used by rows in the SYS.SYSTABLEPERMS, SYS.SYSCOLPERMS, and SYS.SYSROUTINEPERMS system tables.
A PersistentService modularises the access to persistent services, abstracting out details such as finding the list of services to be started at boot time, finding the service.properties file and creating and deleting the persistent storage for a service.
 
An abstract class that is used for physical log operation.
PhysicalUndoOperation is a compensation operation that rolls back the change of an Undo-able operation.
Tracks the most recently piggy-backed session attributes, and provides methods to determine if they have been modified and need to be re-sent to the client.
Class representing a PKGNAMCSN object (RDB Package Name, Consistency Token, and Section Number).
This class is the main entry point to the tool Graphical Query Explainer.
A wrapper-stream able to reposition the underlying store stream.
This interface describes a stream that is aware of its own position and can reposition itself on request.
A Predicate represents a top level predicate.
A PredicateList represents the list of top level predicates.
Inner class which helps statistics routines do their work.
Another inner class which is basically a List of Predicate Wrappers.
The PreparedStatement interface provides methods to execute prepared statements, store them, and get metadata about them.
 
Get a header to prepend to a line of output.
This is a descriptor for schema object which can have privileges granted on it.
 
This node represents a set of privileges that are granted or revoked on one object.
Holder class for Derby genus names.
 
Class to hold a Derby Product version.
A ProjectRestrictNode represents a result set for any of the basic DML operations: SELECT, INSERT, UPDATE, and DELETE.
Takes a table and a table filter and returns the table's rows satisfying the filter as a result set.
List of all properties understood by the system.
Stores properties in a congolmerate with complete transactional support.
Module interface for an Property validation.
PropertyInfo is a class with static methods that set properties associated with a database.
This class defines the names of the properties to use when you extract the parts of a product version from a properties file.
 
There are 5 property objects within a JBMS system. 1) JVM - JVM set - those in System.getProperties 2) APP - Application set - derby.properties file 3) SRV - Persistent Service set - Those stored in service.properties 4) TRAN - Persistent Transactional set - Those stored via the AccessManager interface 5) BOOT - Set by a boot method (rare) This class has a set of static methods to find a property using a consistent search order from the above set.
 
 
A class that represents a key for a module search.
Adapter written to allow for protocol testing from the test package.
A provider is an object that others can build dependencies on.
A ProviderInfo associates a DependableFinder with a UUID that stands for a database object.
ProviderList is a list of Providers that is being tracked for some object other than the current dependent.
Class that wraps StandardExceptions in a SQLException.
A ByteArrayOutputStream which gives a direct reference of the buffer array
USE WITH EXTREME Caution: Purge records from a Page.
Support for pushing SQL statement information down into a virtual table.
A qualified identifier made of a session name and a local name
A structure which is used to "qualify" a column.
QueryTreeNode is the root class for all query tree nodes.
QueryTreeNodeVector is the root class for all lists of query tree nodes.
RAFContainer (short for RandomAccessFileContainer) is a concrete subclass of FileContainer for FileContainers which are implemented on java.io.RandomAccessFile.
RAFContainer4 overrides a few methods in FileContainer/RAFContainer in order to use FileChannel from Java 1.4's New IO framework to issue multiple IO operations to the same file concurrently instead of strictly serializing IO operations using a mutex on the container object.
 
A class that provides interface to be called when undo of an Insert happens in raw store.
 
 
RawContainerHandle is the form of ContainerHandle that is used within the raw store.
 
A Raw store that implements the RawStoreFactory module by delegating all the work to the lower modules TransactionFactory, LogFactory and DataFactory.
RawStoreFactory implements a single unit of transactional storage.
Stream that takes a raw input stream and converts it to the on-disk format of the binary types by prepending the length of the value.
RawTransaction is the form of Transaction used within the raw store.
ReaderToAscii converts Reader (with characters) to a stream of ASCII characters.
Converts the characters served by a java.io.Reader to a stream returning the data in the on-disk modified UTF-8 encoded representation used by Derby.
A read-only version of the log factory.
ResultSetStatistics implemenation for AnyResultSet.
ResultSetStatistics implemenation for BasicNoPutResultSetImpl.
ResultSetStatistics implemenation for CurrentOfResultSet.
ResultSetStatistics implemenation for DeleteCascadeResultSet.
ResultSetStatistics implemenation for DeleteResultSet.
ResultSetStatistics implemenation for DeleteVTIResultSet.
ResultSetStatistics implemenation for DistinctScalarAggregateResultSet.
ResultSetStatistics implemenation for DistinctScanResultSet.
ResultSetStatistics implemenation for GroupedAggregateResultSet.
ResultSetStatistics implemenation for HashJoinResultSet.
ResultSetStatistics implemenation for HashLeftOuterJoinResultSet.
ResultSetStatistics implemenation for HashScanResultSet.
ResultSetStatistics implemenation for HashTableResultSet.
ResultSetStatistics implemenation for IndexRowToBaseRowResultSet.
ResultSetStatistics implemenation for InsertResultSet.
ResultSetStatistics implemenation for InsertVTIResultSet.
ResultSetStatistics implemenation for JoinResultSet.
ResultSetStatistics implemenation for RealLastIndexKeyScanResultSet.
ResultSetStatistics implemenation for MaterializedResultSet.
ResultSetStatistics implemenation for NestedLoopJoinResultSet.
ResultSetStatistics implemenation for NestedLoopLeftOuterJoinResultSet.
ResultSetStatistics implemenation for NoPutResultSetImpl.
ResultSetStatistics implemenation for NormalizeResultSet.
ResultSetStatistics implemenation for NoPutResultSetImpl.
ResultSetStatistics implemenation for OnceResultSet.
ResultSetStatistics implemenation for ProjectRestrictResultSet.
ResultSetStatisticsFactory provides a wrapper around all of objects associated with run time statistics.
 
ResultSetStatistics implemenation for RowResultSet.
ResultSetStatistics implemenation for ScalarAggregateResultSet.
ResultSetStatistics implemenation for ScrollInsensitiveResultSet.
ResultSetStatistics implementation for SetOpResultSet.
ResultSetStatistics implemenation for SortResultSet.
ResultSetStatistics implemenation for TableScanResultSet.
ResultSetStatistics implemenation for UnionResultSet.
ResultSetStatistics implemenation for UpdateResultSet.
ResultSetStatistics implemenation for VTIResultSet.
ResultSetStatistics implementation for WindowResultSet.
Post commit work to reclaim some space from the raw store.
This class helps a BaseDataFactory reclaims unused space.
A handle to a record within a container.
Implementation of RecordHandle.
ReEncodedInputStream passes stream from Reader, which is stream of decoded style, to user of this subclass of InputStream, which is stream of encoded style.
 
 
The data source factory for Derby embedded driver data sources.
Provides information about the columns that are referenced by a CHECK CONSTRAINT definition.
For triggers, ReferencedColumnsDescriptorImpl object has 3 possibilites 1)referencedColumns is not null but referencedColumnsInTriggerAction is null - meaning the trigger is defined on specific columns but trigger action does not reference any column through old/new transient variables.
A ReferencedConstraintDeescriptor is a primary key or a unique key that is referenced by a foreign key.
A Referential Integrity checker for a change to a referenced key (primary or unique).
Build a JBitSet of all of the referenced tables in the tree.
Reflect loader with Privileged block for Java 2 security.
 
 
 
This class implements TypeCompiler for the SQL REF datatype.
Registration of TypedFormat classes.
This interface is an abstraction of a relational operator.
Remap/unremap the CRs to the underlying expression.
A FilterInputStream that remembers read or skipped bytes.
 
 
This class describes actions that are ALWAYS performed for a RENAME TABLE/COLUMN/INDEX Statement at Execution time.
A RenameNode is the root of a QueryTree that represents a RENAME TABLE/COLUMN/INDEX statement.
Replace all aggregates with result columns.
Interface that must be implemented by classes that provide a replacement algorithm for ConcurrentCache.
The interface for the callback objects that ConcurrentCache uses to notify the replacement algorithm about events such as look-ups and removals.
Replace all occurrences of a specific node with another node.
Replace all window function calls with result columns.
Used for the replication master role only.
 
Scan a chunk of log received from the master.
This message is used for the communication between the master and the slave during Replication.
This class is the Receiver (viz.
Used to send replication messages to the slave.
 
An RePreparable operation is an operation that changed the state of the RawStore in the context of a transaction and the locks for this change can be reclaimed during recovery, following redo.
 
This interface provides a representation of the required ordering of rows from a ResultSet.
This is a simple interface that is used by streams that can initialize and reset themselves.
The resource adapter is the clearing house for managing connections, transactions, and XAResources in a JDBC based resource manager living in the distributed transaction processing environment.
 
Interface for Table Functions which can be told which columns need to be fetched plus simple bounds on those columns.
An expression to be pushed into a Table Function so that the Table Function can short-circuit its processing and return fewer rows.
An AND of two Restrictions
A simple comparison of a column to a constant value.
An OR of two Restrictions
A ResultColumn represents a result column in a SELECT, INSERT, or UPDATE statement.
A ResultColumnDescriptor describes a result column in a ResultSet.
A ResultColumnList is the target list of a SELECT, INSERT, or UPDATE.
 
The ResultDescription interface provides methods to get metadata on the results returned by a statement.
The ResultSet interface provides a method to tell whether a statement returns rows, and if so, a method to get the rows.
 
ResultSetFactory provides a wrapper around all of the result sets needed in an execution implementation.
A ResultSetNode represents a result set, that is, a set of rows.
For ease of pushing order by, offset and fetch first/next clauses into nodes.
 
 
 
The ResultSetStatistics interface is used to provide run time statistics information on a specific ResultSet.
ResultSetStatisticsFactory provides a wrapper around all of the result sets statistics objects needed in building the run time statistics.
This class represents a REVOKE statement.
This class performs actions that are ALWAYS performed for a REVOKE role statement at execution time.
This class represents a REVOKE role statement.
 
Do a merge run comparing all the foreign keys from the foreign key conglomerate against the referenced keys from the primary key conglomerate.
Checks a set or referential integrity constraints.
Implements the row level locking accessmanager.
Allows iterator over the role grant closure defined by the relation GRANT role-a TO role-b, or its inverse.
Allows iterator over the role grant closure defined by the relation GRANT role-a TO role-b, or its inverse.
This class is used by rows in the SYS.SYSROLES system table.
This class provides rolling file OutputStream.
Creates and configures a RollingFileStream
Describe a routine (procedure or function) alias.
This node represents a routine signature.
This class describes rows in the SYS.SYSROUTINEPERMS system table, which keeps track of the routine (procedure and function) permissions that have been granted but not revoked.
 
The Row interface provides methods to get information about the columns in a result row.
Perform row at a time DML operations of tables and maintain indexes.
Perform row at a time DML operations of tables and maintain indexes.
Allows clients to read and write row count estimates for conglomerates.
The result set generated by this node (RowCountResultSet) implements the filtering of rows needed for the and the .
This result set implements the filtering of rows needed for the and the .
Holds the location of a row within a given conglomerate.
A RowLocationRetRowSource is the mechanism for iterating over a set of rows, loading those rows into a conglomerate, and returning the RowLocation of the inserted rows.
A RowLock represents a qualifier that is to be used when locking a Row through a RecordHandle.
A locking policy that implements row level locking with isolation degree 1.
A locking policy that implements row level locking with isolation degree 2.
A locking policy that implements row level locking with isolation degree 2, never holding read locks after they are granted.
A locking policy that implements row level locking with isolation degree 3.
A locking policy that implements row level locking with isolation degree 3.
A locking policy that implements row level locking with repeatable read isolation.
Row data type as described in the 2003 SQL spec in part 2, section 4.8.
Class that represents a call to the ROW_NUMBER() window function.
This interface provides a representation of the ordering of rows in a ResultSet.
 
Just an easy way to pass information back and forth about current position of a row in a table.
Takes a constant row value and returns it as a result set.
A RowResultSetNode represents the result set for a VALUES clause.
A RowSource is the mechanism for iterating over a set of rows.
A row trigger executor is an object that executes a row trigger.
A set of static utility methods to work with rows.
Utility class manipulating rows.
The run class facilitates running the various Derby utilities with the java -jar command.
A RunTimeStatistics object is a representation of the query execution plan and run time statistics for a java.sql.ResultSet.
RunTimeStatistics implemenation.
The SanityService provides assertion checking and debug control.
 
This class describes actions that are ALWAYS performed for a Savepoint (rollback, release and set savepoint) Statement at Execution time.
A SavepointNode is the root of a QueryTree that represents a Savepoint (ROLLBACK savepoint, RELASE savepoint and SAVEPOINT) statement.
This ResultSet evaluates scalar, non distinct aggregates.
Abstract base class for all sort classes which return rows from the sort.
Scan the the log which is implemented by a series of log files.n This log scan knows how to move across log file if it is positioned at the boundary of a log file and needs to getNextRecord.
A scan is the mechanism for iterating over the rows in a conglomerate, the scan controller is the interface through which access clients control the underlying scan.
A ScanControllerRowSource is both a RowSource and a ScanController.
Inteface for scanning the log from outside the RawStore.
This object provides performance information related to an open scan.
The ScanManager interface contains those methods private to access method implementors necessary to implement Scans on Conglomerates.
 
ScanQualifier provides additional methods for the Language layer on top of Qualifier.
Abstract ResultSet class for NoPutResultSets which contain a scan.
This class represents a schema descriptor
Filter which passes Visitables only if the compiler is inside a named scope.
Provide insensitive scrolling functionality for the underlying result set.
A ScrollInsensitiveResultSetNode represents the insensitive scrolling cursor functionality for any child result set that needs one.
Parameters that are passed down during a recursive b-tree search.
 
 
Operations which can be secured.
This class provides helper functions for security-related features.
A SelectNode represents the result set for any of the basic DML operations: SELECT, INSERT, UPDATE, and DELETE.
This class is used by rows in the SYS.SYSSEQUENCES system table.
This is a generic machine for pre-allocating ranges of sequence numbers in order to improve concurrency.
Logic to determine how many values to pre-allocate for a sequence.
Default Derby logic for determining how many values to pre-allocate for an identity column or sequence.
An object cached in the data dictionary which manages new values for sequences.
Implementation of SequenceUpdater for use with the bulk-insert optimization used by InsertResultSet.
Specific implementation of SequenceUpdater for the sequences managed by SYSSEQUENCES.
To use a DaemonService, one implements the Serviceable interface.
A context that is used during a service boot to stop cleanup on the stack at this point.
wrapper class for basic daemon's clients
Session stores information about the current session It is used so that a DRDAConnThread can work on any session.
Session holds the objects local to a particular database session, which starts with a connection and is all other JDBC stuff used on that connection, along with some ij state that is connection-based as well.
This class describes actions that are performed for a set constraint at execution time.
A SetConstraintsNode is the root of a QueryTree that represents a SET CONSTRAINTS statement.
A SetOperatorNode represents a UNION, INTERSECT, or EXCEPT in a DML statement.
Takes the result set produced by an ordered UNION ALL of two tagged result sets and produces the INTERSECT or EXCEPT of the two input result sets.
Represents shrinking of the reserved space of a particular row on a page.
This class describes actions that are ALWAYS performed for a SET ROLE Statement at Execution time.
A SetRoleNode is the root of a QueryTree that represents a SET ROLE statement.
This class describes actions that are ALWAYS performed for a SET SCHEMA Statement at Execution time.
A SetSchemaNode is the root of a QueryTree that represents a SET SCHEMA statement.
This class describes actions that are ALWAYS performed for a SET TRANSACTION ISOLATION Statement at Execution time.
A SetTransactionIsolationNode is the root of a QueryTree that represents a SET TRANSACTION ISOLATION command
This is a wrapper class which invokes the Execution-time logic for SET TRANSACTION statements.
 
This class is intended to be used a the qualifier class for ShExLockable.
A ShutdownException is a runtime exception that is used to notify code that the system has/is being shut down.
This class shows which user declared SQL functions and procedures cannot be matched with Java methods.
 
 
Converters from signed binary bytes to Java short, int, or long.
This node represents a unary upper or lower operator
A SingleChildResultSetNode represents a result set with a single child.
The Basic Services provide InfoStreams for reporting information.
 
This class implements the TimerFactory interface.
This interface extends the Cacheable interface (@see Cacheable) with a method that estimates the size of the Cacheable object, in bytes.
Encapsulates the host name and the port number of the slave machine.
This is an implementation of the replication slave controller service.
SlaveDatabase is an instance of Database, and is booted instead of BasicDatabase if this database will have the replication slave role.
This is the interface for the replication slave controller service.
This class encapsulates a Socket connection and has methods that allow to read and write into the Object streams created from this connection.
The sort interface corresponds to an instance of an in-progress sort.
This class implements an in-memory ordered set based on the balanced binary tree algorithm from Knuth Vol. 3, Sec. 6.2.3, pp. 451-471.
Wrapping the output of a SortBuffer in a RowSource for the benefit of the createAndLoadConglomerate and loadConglomerate interface.
A sort scan that just reads rows out of a sorter.
A sort controller is an interface for inserting rows into a sort.
 
The factory interface for all sort access methods.
This object provides performance information related to a sort.
A SortObserver is an object that is used as a callback by the sorter.
Takes a source result set, sends it to the sorter, and returns the results.
Abstract base class for merge sort scans.
Manage the result information from a single call to ConglomerateController.getSpaceInfo().
Manage the result information from a single call to ConglomerateController.getSpaceInfo().
SpaceTable is a virtual table that shows the space usage of a particular table and its indexes.
SpecialFunctionNode handles system SQL functions.
This authentication service is a specific/user defined User authentication level support.
A SPSDescriptor describes a Stored Prepared Statement.
This class implements a Cacheable for a DataDictionary cache of sps descriptors, with the lookup key being the name/schema of the sps.
SQLBinary is the abstract class for the binary datatypes.
SQLBit represents the SQL type CHAR FOR BIT DATA
SQLBlob satisfies the DataValueDescriptor, interfaces (i.e., OrderableDataType).
SQLBoolean satisfies the DataValueDescriptor interfaces (i.e., DataType).
 
The SQLChar represents a CHAR value with UCS_BASIC collation.
SQLClob represents a CLOB value with UCS_BASIC collation.
Holder class for header information gathered from the raw byte header in the stream.
 
This contains an instance of a SQL Date.
SQLDecimal satisfies the DataValueDescriptor interfaces (i.e., OrderableDataType).
SQLDouble satisfies the DataValueDescriptor interfaces (i.e., OrderableDataType).
 
SQLException factory class to create jdbc 40 exception classes
Class to create SQLException
Wrapper class for SQLExceptions
SQLInteger represents an INTEGER value.
SQLLongint satisfies the DataValueDescriptor interfaces (i.e., OrderableDataType).
SQLLongVarbit represents the SQL type LONG VARCHAR FOR BIT DATA It is an extension of SQLVarbit and is virtually indistinguishable other than normalization.
SQLLongvarchar represents a LONG VARCHAR value with UCS_BASIC collation.
SQLReal satisfies the DataValueDescriptor interfaces (i.e., OrderableDataType).
 
An implementation of this interface encapsulates some of the SQL session context's state variables, cf.
 
SQLSmallint satisfies the DataValueDescriptor interfaces (i.e., OrderableDataType).
This is a refactoring wrapper around the "real" SQLState.java, which has been relocated to org.apache.derby.shared.common.reference
List of error message identifiers.
This contains an instance of a SQL Time Our current implementation doesn't implement time precision so the fractional seconds portion of the time is always 0.
This contains an instance of a SQL Timestamp object.
SQLTinyint satisfies the DataValueDescriptor interfaces (i.e., OrderableDataType).
This node type converts a value in the SQL domain to a value in the Java domain.
 
SQLVarbit represents the SQL type VARCHAR FOR BIT DATA It is an extension of SQLBit and is virtually indistinguishable other than normalization.
SQLVarchar represents a VARCHAR value with UCS_BASIC collation.
This represents a warning versus a full exception.
This class generates SQLWarning instances.
This class contains "utility" methods that work with XML-specific objects that are only available if JAXP and/or Xalan are in the classpath.
A NamespaceContext that reports all namespaces as unbound.
StandardException is the root of all exceptions that are handled in a standard fashion by the database code, mainly in the language code.
Dummy exception to catch incorrect use of StandardException.newException(), at compile-time.
Implementation of InputStream which get EXTDTA from the DDMReader.
The Statement interface provides a way of giving a statement to the language module, preparing the statement, and executing it.
StatementCache is a virtual table that shows the contents of the SQL statement cache.
Utility class encapsulating the logic for interacting with the JDBC statement cache when creating new logical statements.
 
This class describes a column permission used (required) by a statement.
StatementContext keeps the context for a statement.
StatementDuration is a virtual table which can be used to analyze the execution duration of the statements of "interest" in db2j.log or a specified file when db2j.language.logStatementText=true.
StatementGrabber looks through an input stream for the next JSQL statement.
This class describes a generic permission (such as USAGE) required by a statement.
A key representing a java.sql.PreparedStatement or a java.sql.CallableStatement.
A factory for creating JDBC statement keys for use with the JDBC statement cache.
A StatementNode represents a single statement in the language.
This class describes a permission require by a statement.
 
 
 
This class describes a role permission required by a statement.
This class describes a routine execute permission required by a statement.
This class describes a schema permission required by a statement.
This class describes a table permission required by a statement.
A statement trigger executor is an object that executes a statement trigger.
Different types of statements
Utilities for dealing with statements.
A StaticClassFieldReferenceNode represents a Java static field reference from a Class (as opposed to an Object).
Information that can be "compiled" once and then used over and over again at execution time.
A StaticMethodCallNode represents a static method call from a Class (as opposed to from an Object).
This interface is used in the column SYS.SYSSTATISTICS.STATISTICS.
Implementation of StatisticsDescriptor.
 
This class implements the SQL Standard STDDEV_POP() aggregator, computing a population's standard deviation.
This class implements the SQL Standard STDDEV_SAMP() aggregator, computing a sample's standard deviation.
Formatable for holding SQL data (which may be null).
 
The Statement interface is an extension of exec prepared statement that has some stored prepared specifics.
This interface provides basic storage functions needed for read only databases.
This class implements the PersistentService interface using a StorageFactory class.
Helper class for common file operations on the service properties files.
This interface abstracts file naming.
This interface abstracts an object that implements reading and writing on a random access file.
 
The StoreCostController interface provides methods that an access client (most likely the system optimizer) can use to get store's estimated cost of various operations on the conglomerate the StoreCostController was opened for.
Manage the result information from a single call to StoreCostController.getScanCost().
A class to provide static methods to manipulate fields in the field header.
A format id identifies a stored form of an object for the purposes of locating a class which can read the stored form and reconstruct the object using the java.io.Externalizable interface.
StoredPage is a sub class of CachedPage that stores page data in a fixed size byte array and is designed to be written out to a file through a DataInput/DataOutput interface.
A class StoredPage uses to cache record headers by passing instances to BasePage, and to write stored versions of record headers.
Class which holds the fields overflowId, overflowPage and firstField, which are not needed when there is no overflow.
A read-only Clob representation operating on streams out of the Derby store module.
A Stream Container handle
The format of this stream file is: (RH) (FH) (field data) (FH) (field data) ........
A handle to an open stream container, implememts StreamContainerHandle.
Generates stream headers encoding the length of the stream.
LogScan provides methods to read a log record and get its LogInstant in an already defined scan.
Streaming interface for a data value.
This is an abstract table function which assumes that all columns are strings and which coerces the strings to reasonable values for various getXXX() methods.
 
A set of public static methods for dealing with Strings
This interface is used to get information from a SubCheckConstraintDescriptor.
This interface is used to get information from a SubConstraintDescriptor.
This interface is used to get information from a SubKeyConstraintDescriptor.
A SubqueryList represents a list of subqueries within a specific clause (select, where or having) in a DML statement.
A SubqueryNode represents a subquery.
Replaces a source expression with a target expression.
Aggregator for SUM().
Definition for the SUM()/AVG() aggregates.
Flush all pages for a table on a commit
Describe an S (Synonym) alias.
Factory for creating a SYSALIASES row.
Factory for creating a SYSCHECKS row.
Factory for creating a SYSCOLPERMS row.
Factory for creating a SYSCOLUMNS row.
Factory for creating a SYSCONGLOMERATES row.
Factory for creating a SYSCONTRAINTS row.
Factory for creating a SYSDEPENDSS row.
Factory for creating a SYSDUMMY1 row.
Factory for creating a SYSFILES row.
Factory for creating a SYSFOREIGNKEYS row.
This class displays system information to system out.
Factory for creating a SYSKEYS row.
Factory for creating a SYSPERMS row.
Factory for creating a SYSROLES row.
Factory for creating a SYSROUTINEPERMS row.
Factory for creating a SYSSCHEMAS row.
Factory for creating a SYSSEQUENCES row.
Factory for creating a SYSSTATEMENTS row.
Factory for creating a SYSSTATISTICS row.
Factory for creating a SYSTABLEPERMS row.
Factory for creating a SYSTABLES row.
Abstract aggregator that is extended by all internal (system) aggregators.
Implements the description of a column in a system table.
Implements the description of a column in a system table.
A context that shuts the system down if it gets an StandardException with a severity greater than or equal to ExceptionSeverity.SYSTEM_SEVERITY or an exception that is not a StandardException.
This class represents access to system-wide Derby privileges.
A collection of SystemPermission objects.
This class represents Derby's notion of a principal, a concept of user identity with controlled access to Derby System Privileges.
Some system built-in procedures, and help routines.
Factory for creating a SYSTRIGGERS row.
Factory for creating a SYSUSERS row.
Factory for creating a SYSVIEWS row.
A poor mans structure used in DataDictionaryImpl.java.
This class represents a table descriptor.
A TableElementList represents the list of columns and other table elements such as constraints in a CREATE TABLE or ALTER TABLE statement.
A TableElementNode is an item in a TableElementList, and represents a single table element such as a column or constraint in a CREATE TABLE or ALTER TABLE statement.
A TableKey represents a immutable unique identifier for a SQL object.
A TableName represents a qualified name, externally represented as a schema name and an object name separated by a dot.
 
A TableOperatorNode represents a relational operator like UNION, INTERSECT, JOIN, etc. that takes two tables as parameters and returns a table.
This class describes a row in the SYS.SYSTABLEPERMS system table, which stores the table permissions that have been granted but not revoked.
 
This class represents a set of privileges on one table.
Takes a table and a table filter and returns the table's rows satisfying the filter as a result set.
The HeapController_D class implements the Diagnostics protocol for the HeapController class.
Filter which passes Visitables which have been marked with a given tag.
The TargetResultSet interface is used to provide additional operations on result sets that are the target of a bulk insert or update.
This class implements a Cacheable for a DataDictionary cache of table descriptors.
 
A Clob representation where the Clob is stored either in memory or on disk.
A simple class to hold the byte position for a character position.
This is a class that is used to temporarily (non-persistently) hold rows that are used in language execution.
This is a class that is used to temporarily (non-persistently) hold rows that are used in language execution.
A result set to scan temporary row holders.
needsSync is never true - DONE An exception never marks the store as corrupt clean() does not stubbify preAllocate() does nothing - DONE getFileName() returns a file in the tmp directory - DONE flushAll does nothing - DONE file descriptor is never synced
The temp tables will have following data structure TableDescriptor Declared in savepoint level Dropped in savepoint level Modified in savepoint level The actual logic LanguageConnectionContext will keep the "current savepoint level".
A TernaryOperatorNode represents a built-in ternary operators.
A TestConstraintNode is used to determine when a constraint has been violated.
 
 
Code to support Timeout error output.
This class provides access to Timer objects for various purposes.
The TimestampOperatorNode class implements the timestamp( date, time) function.
 
 
Base class for the Token class generated by JavaCC.
 
A description of an instance of a module.
 
Provide support to transactions to manage sets of actions to perform at transaction boundaries.
The TransactionController interface provides methods that an access client can use to control a transaction, which include the methods for gaining access to resources (conglomerates, scans, etc.) in the transaction controller's storage manager.
This module is intended to be used only within the RawStore.
A transaction identifier that is only unique within a raw store, do not ever pass this out of raw store.
 
An interface that must be implemented by a object that wants to be notified when a significant transaction event occurs.
The TransactionManager interface provides methods on the transaction needed by an access method implementer, but should not be visible to clients of a TransactionController.
An instance of a TransactionResourceImpl is a bundle of things that connects a connection to the database - it is the transaction "context" in a generic sense.
A TransactionStatementNode represents any type of Transaction statement: SET TRANSACTION, COMMIT, and ROLLBACK.
TransactionTable is a virtual table that shows all transactions currently in the database.
The transaction table is used by the transaction factory to keep track of all transactions that are in the system.
Interface for visiting entries in the transaction table.
Transaction table entry is used to store all relevant information of a transaction into the transaction table for the use of checkpoint, recovery, Transaction management during Quiesce state, and for dumping transaction table.
This class is used by PlanExporter tool (DERBY-4587) as a data structure to keep the values retrieved after querying XPLAIN tables and few other properties of a plan node in a query plan.
A trigger.
 
This is a simple class that we use to track trigger events.
Responsible for firing a trigger or set of triggers based on an event.
Static final trigger events.
A trigger execution context holds information that is available from the context of a trigger invocation.
This is a simple class used to store the run time information about a foreign key.
Provides information about about a a set of new rows created by a trigger action.
Provides information about a set of rows before a trigger action changed them.
Rudimentary structure for containing information about a REFERENCING clause for a trigger.
Truncate a temp table on a commit, abort or rollback to savepoint
This is the superclass of all Descriptors.
A TupleFilter is used to qualify rows from a tuple stream.
 
 
This interface defines methods associated with a TypeId that are used by the compiler.
Factory interface for the compilation part of datatypes.
 
TypeDescriptor represents a type in a system catalog, a persistent type.
 
Derby interface for identifying the format id for the stored form of an object.
TypeId describes the static information about a SQL type independent of any specific attributes of the type such as length.
 
An implementation of interface CharStream, where the stream is assumed to contain only Unicode characters.
An implementation of interface CharStream, where the stream is assumed to contain only Unicode characters.
Describe an A (Abstract Data Type) alias.
This node represents a unary arithmetic operator
This node is the superclass for all unary comparison operators, such as is null and is not null.
This class implements the timestamp( x) and date(x) functions.
 
A UnaryOperatorNode represents a built-in unary operator as defined by the ANSI/ISO SQL standard.
An Undoable operation is an operation that changed the state of the RawStore in the context of a transaction and this change can be rolled back.
A class that provides interface to be called with undo of an Insert happens in raw store.
A UnionNode represents a UNION in a DML statement.
Takes two result sets and returns their union (all).
Unique index aggregator.
This is a descriptor for something that is a SQL object that has the following properties: resides in a schema has a name (that is unique when combined with schema) has a unique identifier (UUID) UUIDS.
Extension for Tuple Descriptors that have UUIDS.
Method factory to support sorting of Almost unique index.
UniqueWithDuplicateNullsIndexSortObserver is implementation of BasicSortObserver for eliminating non null duplicates from the backing index of unique constraint.
This class extends and customizes MergeSort to support unique indexes with duplicate nulls.
 
An UntypedNullConstantNode represents a SQL NULL before it has been bound.
Updatable blob stream is a wrapper stream over dvd stream and LOBInputStream.
This class describes compiled constants that are passed into Updatable VTIResultSets.
An abstract implementation of PreparedStatement (JDBC 3.0) that is useful when writing a read-write (updatable) virtual table interface (VTI).
This class describes compiled constants that are passed into UpdateResultSets.
Represents the update of a particular field of a row on a page.
UpdateLoader implements then functionality of derby.database.classpath.
An UpdateNode represents an UPDATE statement.
Represents the update of a particular row on a page.
Update the rows from the specified base table.
This class extends from the UpdateSensitiveLOBLocatorInputStream and creates and returns an implementation of the Blob specific locator InputStream.
This class extends from the UpdateSensitiveLOBLocatorInputStream and creates and returns an implementation of the Clob specific locator InputStream.
Wraps a Buffered Clob locator reader and watches out for updates on the Clob associated with it.
Super-class of the Update sensitive locator streams.
 
Update the rows from the source into the specified base table.
This class takes a string used for a connection URL and checks for correctness.
This class provides a http based implementation of the StorageFile interface.
This class provides a http based implementation of the StorageFactory interface.
Definition for user-defined aggregates.
The UserAuthenticator interface provides operations to authenticate a user's credentials in order to successfully connect to a database.
 
Aggregator for user-defined aggregates.
 
This type id describes a user defined type.
A Descriptor for a user stored in SYSUSERS.
This contains an instance of a user-defined type, that is, a java object.
User type constants.
A class that is used to store java.lang.Strings and provide ordering capability.
 
 
Class for reading characters from streams encoded in the modified UTF-8 format.
Utility methods for handling UTF-8 encoded byte streams.
Helper class to hold skip counts; one for chars and one for bytes.
 
Methods used to control setup for apps as well as display some internal ij structures.
This class understands the message protocol and looks up SQLExceptions based on keys, so that the Local JDBC driver's messages can be localized.
Utility methods for JDBC 4.2
This class is utilities specific to the two ij Main's.
 
Utility methods for JDBC 4.2.
An interface for accessing Derby UUIDs, unique identifiers.
Generates and recreates unique identifiers.
Special result set used when checking deferred CHECK constraints.
A ValueNode is an abstract class for all nodes that can represent data values, that is, constants, columns, and expressions.
A ValueNodeList represents a list of ValueNodes within a specific predicate e.g.
Basic implementation of ExecRow.
 
The VariableSizeDataValue interface corresponds to Datatypes that have adjustable width.
This class implements the SQL Standard VAR_POP() aggregator, computing a population's variance.
 
This class implements the SQL Standard VAR_SAMP() aggregator, computing the variance over a sample.
If a RCL (SELECT list) contains an aggregate, then we must verify that the RCL (SELECT list) is valid.
 
This implementation of VersionMBean instruments a ProductVersionHolder object.
This interface defines a Standard MBean for exposing the version information of a running Derby component.
A storage factory for virtual files, where the contents of the files are stored in main memory.
This is the implementation of ViewDescriptor.
A VirtualColumnNode represents a virtual column reference to a column in a row returned by an underlying ResultSetNode.
Represents a file in the virtual file system.
This class acts as a conduit of information between the lock manager and the outside world.
A random access file capable of reading and writing from/into a virtual file whose data is represented by a BlockedByteArray.
A Visitable is something that can be visited by a Visitor
Filter for qualifying Visitables.
A visitor is an object that traverses the querytree and performs some action.
 
This contains all the opcodes for the JVM as defined in The Java Virtual Machine Specification.
This class implements a Cacheable for a Byte code generator cache of VMTypeIds.
Context parameter which is passed to an AwareVTI.
VTICosting is the interface that the query optimizer uses to cost Table Functions.
This class applies a VTI modification deferral policy to a statement to see whether it should be deferred.
VTIEnvironment is the state variable created by the optimizer to help it place a Table Function in the join order.
An abstract implementation of ResultSetMetaData (JDBC 1.2) that is useful when writing a VTI (virtual table interface).
 
An abstract implementation of ResultSet that is useful when writing table functions, read-only VTIs (virtual table interface), and the ResultSets returned by executeQuery in read-write VTI classes.
A struct class which is useful for describing columns and parameters.
This error is never seen outside of the btree implementation.
This class represents an OLAP window definition.
Superclass of any window function call.
A WindowList represents the list of windows (definitions) for a table expression, either defined explicitly in a WINDOW clause, or inline in the SELECT list or ORDER BY clause.
Superclass of window definition and window reference.
Represents a reference to an explicitly defined window
WindowResultSet This ResultSet handles a window function ResultSet.
A WindowResultSetNode represents a result set for a window partitioning on a select.
WorkHorseForCollatorDatatypes class holds on to RuleBasedCollator, and the base SQLChar object for the collation sensitive SQLChar, SQLVarchar, SQLLongvarchar and SQLClob.
This interface extends StorageFactory to provide read/write access to storage.
This abstract class describes compiled constants that are passed into Delete, Insert, and Update ResultSets.
 
A transaction has five states CLOSED - cannot be used IDLE - no reads have been performed by the transaction.
The context associated with the transaction.
 
Use this class for a short hand representation of the transaction.
The XactXAResourceManager implements the Access XAResource interface, which provides offline control over two phase commit transactions.
This class contains database state specific to XA, specifically the XAResource that will be used for XA commands.
 
 
This interface allows access to commit,prepare,abort global transactions as part of a two phase commit protocol.
The Statement returned by an Connection returned by a XAConnection needs to float across the underlying real connections.
This interface allows access to commit,prepare,abort global transactions as part of a two phase commit protocol, during runtime.
 
The implementation of TimerTask to cancel a global transaction.
A class used to monitor if the transaction is in the middle of cancelling or cleaning up on an error.
The XAXactId class is a specific implementation of the JTA Xid interface.
This type implements the XMLDataValue interface and thus is the type on which all XML related operations are executed.
 
 
Optimizer tracer which produces output in an xml format.
 
This class implements TypeCompiler for the XML type.
This is a VTI designed to read XML files which are structured like row sets.
This interface has to be implemented by object structures, which want to get explained.
This is the Default Visitor which produces explain information like the old getRuntimeStatistics() approach.
This is the module implementation of the XPLAINFactoryIF.
This is the factory interface of the XPLAINFactory facility.
 
 
 
This class describes a Tuple for the XPLAIN_SORT_PROPS System Table.
 
 
This is the Visitor, which explains the information and stores the statistics in the system catalogs.
 
This class contains helper methods, which support the System Table Visitor.
Classes, which implement this interface have the ability to explain the gathered ResultSetStatistics.