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.
Use
EmbeddedConnectionPoolDataSource instead.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.
Use
EmbeddedXADataSource instead.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.
See also
IndexRowGenerator.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.
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.
ClientConnectionPoolDataSourceinstead.