All Classes and Interfaces
Class
Description
Provides convenience methods for handling aggregate functions (functions
that are evaluated over a grouping set).
An implementation of a list of integer values that are stored across
an array of blocks.
This is the abstract class implemented by a DataTable like table.
An abstract implementation of DBConfig.
An abstract implementation of Function.
An abstract implementation of JDBCDatabaseInterface that provides a
connection between a single DatabaseConnection and a DatabaseInterface
implementation.
An abstract implementation of QueryContext
Provides an abstract implementation of Store.
Logic for the ALTER TABLE SQL statement.
Represents an action in an ALTER TABLE SQL statement.
An interface for access the contents of an area of a store.
The interface used for setting up an area initially in a store.
A java.io.Reader implementation that wraps around an ascii input stream
(8-bit per char stream).
An assignment from a variable to an expression.
Extends BigDecimal to allow a number to be positive infinity, negative
infinity and not-a-number.
A Reader implementation that wraps around a unicode encoded input stream
that encodes each unicode character as 2 bytes.
This is a scheme that performs a blind search of a given set.
An interface that provides access to basic information about a BLOB so that
we may compare BLOBs implemented in different ways.
A lightweight interface that is a reference to a blob in a BlobStore.
A very restricted interface for accessing a blob store.
An implementation of AbstractBlockIntegerList that stores all int values in
blocks that are entirely stored in main memory.
The block that contains the actual int values of the list.
Object used to represent a column in the 'order by' and 'group by'
clauses of a select statement.
Static utilities for byte arrays.
A wrapper for an array of byte[].
A byte array that can be transferred between the client and server.
Represents a cache of Objects.
A statement that calls a procedure, and returns a resultant table.
Methods to choose and perform casts from database type to Java types.
Various utility methods for helping to cast a Java object to a type that
is conformant to an SQL type.
This is a ByteArrayOutputStream that allows access to the underlying byte
array.
A reference to a large character object in the database.
An implementation of SelectableScheme that is based on some collated set of
data.
Represents a column definition (description).
This is a description of a column and the data it stores.
Used to parse a command-line.
Statement that handles COMPACT sql command.
This represents either a COMMIT or ROLLBACK SQL command.
A composite of two or more datasets used to implement UNION, INTERSECTION,
and DIFFERENCE.
A trigger manager on a DatabaseConnection that maintains a list of all
triggers set in the database, and the types of triggers they are.
Represents a constraint definition (description) for a table.
A wrapper for a variable in a sub-query that references a column outside
of the current query.
A parsed state container for the 'create' statement.
A parsed state container for the 'CREATE TRIGGER' statement.
The representation of a single database in the system.
An interface that is input to the DatabaseInterface as a way to be
notified of event information from inside the database.
An object that represents a connection to a Database.
Call back interface for events that occur within the connection instance.
Contant static values that determine several parameters of the database
operation.
A database exception that represents a constraint violation.
Exception thrown where various problems occur within the database.
The interface with the Database whether it be remotely via TCP/IP or
locally within the current JVM.
This interface represents a database procedure that is executed on the
server side.
An implementation of a QueryContext based on a DatabaseConnection object.
This class provides information about shared resources available for the
entire database system running in this VM.
A tool for converting between different versions of the database file
system.
Represents index meta-information on a table.
Represents the meta-data for a set of indexes of a table.
DataTable is a wrapper for a MutableTableDataSource that fits into the
query hierarchy level.
All the information regarding a column in a table.
A definition of a table.
This object sits on top of a DataTable object filtering out certain types
of calls.
A container object of configuration details of a database system.
An interactive tool for diagnosing the contents of a TableDataConglomerate
object.
A command line repair tool for repairing a corrupted conglomerate.
An object that provides methods for creating and controlling database
systems in the current JVM.
An object used to access and control a single database system running in
the current JVM.
Deprecated.
use DebugLogger implementations instead.
An interface for logging errors, warnings, messages, and exceptions in the
Mckoi system.
This represents a default implementation of a DataTable.
Implements a default database configuration that is useful for setting up
a database.
A default implementation of DebugLogger that logs messages to
a PrintWriter object.
A bootable object that filters through to a JDBCDatabaseInterface but
is thread-safe and multi-threaded.
Logic for the DELETE FROM SQL statement.
The logic of the 'DROP TABLE' SQL command.
A parsed state container for the 'DROP TRIGGER' statement.
An expression that can be evaluated in a statement.
An interface used to prepare an Expression object.
A table that is a filter for another table.
A structure that provides a fast way to read and write fixed sized nodes in
a Store object.
A file format that allows for the very quick retreival of data that is
stored within it.
A container for the From clause of a select statement.
Describes a single table declaration in the from clause of a table
expression (SELECT).
An implementation of FromTableInterface that wraps around an
TableName/AbstractDataTable object.
A single table resource item in a query which handles the behaviour
of resolving references to columns as well as providing various base
utility methods for resolving general variable names.
An implementation of FromTableInterface that wraps around a
TableSelectExpression object as a sub-query source.
Represents a function that is part of an expression to be evaluated.
A handler for defining and dropping functions.
A definition of a function including its name and parameters.
A factory that generates Function objects given a function name and a
set of expression's that represent parameters.
Meta information about a function.
An interface that resolves and generates a Function objects given a
FunctionDef object.
A table that has a number of columns and as many rows as the refering
table.
This class provides several static convenience functions for formatting
various types of information such as a time frame.
This class provides several static convenience functions for parsing
various types of character sequences.
A class that manages the grants on a database for a given database
connection and user.
Similar to VariableResolver, this method is used by grouping Functions to
find information about the current group being evaluated (used for
evaluating aggregate functions).
A GTDataSource that maps a Privs 11-bit set to strings that represent the
priv in human understandable string.
A GTDataSource that models all SQL types that are available.
A HashMap that maps from a source to a list of items for that source.
An implementation of the Store interface that persists information in the
volatile JVM heap memory.
A comparator that is used within BlockIntegerList that compares two int
values which are indices to data that is being compared.
A set of list of indexes.
A class that manages the storage of a set of transactional index lists in a
way that is fast to modify.
The instance class that stores all the information about an insert
statement for processing.
This is a SelectableScheme similar in some ways to the binary tree.
An iterator for a list of integer's.
A block of an AbstractBlockIntegerList.
An interface for querying and accessing a list of primitive integers.
Similar to the Vector class, except this can only store integer values.
A bridge to the internal Java regular expression library that was introduced
in Java 1.4.
An implementation of jdbc.DatabaseInterface on the server-side.
Instance class that registers the mckoi JDBC driver with the JDBC
Driver Manager.
A graphical interactive SQL query tool that allows for queries to be
executed to a JDBC driver.
A tool that reads an input SQL script and output information for the
result either to an output file or through System.out.
A Table that represents the result of one or more other tables joined
together.
Used in TableSet to describe how we naturally join the tables together.
An implementation of AbstractStore that persists to an underlying data
format via a robust journalling system that supports check point and crash
recovery.
Reads a command block on the underlying stream that is constrained by
a length marker preceeding the command.
An interface that is implemented by an object that boots up the database.
This is a lock on a table in the LockingMechanism class.
This represents a handle for a series of locks that a query has over the
tables in a database.
This class represents a model for locking the tables in a database during
any sequence of concurrent read/write accesses.
A log file/stream that logs some information generated by the system.
A paged random access buffer manager that caches access between a Store and
the underlying filesystem and that also handles check point logging and
crash recovery (via a JournalledSystem object).
A factory interface for creating StoreDataAccessor objects from resource
names.
A Writer that writes information to a log file that archives old log
entries when it goes above a certain size.
Debug level static values.
Wraps a Connection and provides Mckoi specific extensions that are
outside the JDBC specification.
The start point of the Mckoi SQL database server.
JDBC implementation of the connection object to a Mckoi database.
An implementation of JDBC's DatabaseMetaData.
JDBC implementation of the driver for the Mckoi database.
Misc statements that I couldn't be bothered to roll a new Statement class
for.
Implementation of a ResultSet.
An implementation of JDBC's ResultSetmetaData.
SQLException used by the McKoi database engine.
An interface for an area that can be modified.
A mutable data source that allows for the addition and removal of rows.
A table that is the cartesian product of two tables.
A no operation statement.
Deprecated.
do not use.
Provides static methods for transfering different types of objects over
a Data input/output stream.
This object compliments ObjectTransfer and provides a method to translate
any object into a type the database engine can process.
An operator for an expression.
An implementation of InputStream that reads data from an underlying
representation in fixed sized pages.
An object that represents a constant value that is to be lately binded to
a constant value in an Expression.
This exception is thrown when parse errors are encountered.
This is a static class that performs the operations to do a pattern search
on a given column of a table.
Various methods for forming query plans on SQL queries.
A set of privileges to grant a user for an object.
Handler for grant/revoke queries for setting up grant information in the
database.
An interface for accessing a database connection inside a stored procedure.
An exception that is generated from a stored procedure when some erronious
condition occurs.
A DatabaseConnection procedure manager.
The name of a procedure as understood by a ProcedureManager.
Constants used in the JDBC database communication protocol.
Encapsulates the information in a query to the database.
A class that is an agent for queries from the client environment to the
server.
Facts about a particular query including the root table sources, user name
of the controlling context, sequence state, etc.
Various helper methods for constructing a plan tree, and the plan node
implementations themselves.
A QueryPlanNode that is a branch with two child nodes.
A cache point node that only evaluates the child if the result can not
be found in the cache with the given unique id.
A branch node for performing a composite function on two child nodes.
The node for evaluating an expression that contains entirely constant
values (no variables).
The node for merging the child node with a set of new function columns
over the entire result.
The node for performing a distinct operation on the given columns of the
child node.
A branch node for equi-joining two tables together given two sets of
columns.
The node for performing a exhaustive select operation on the child node.
The node for fetching a table from the current transaction.
The node that fetches a view from the current connection.
The node for performing a functional select operation on the child node.
The node for performing a grouping operation on the columns of the child
node.
A branch node for a non-equi join between two tables.
A branch node for a left outer join.
A branch node for a logical union of two tables of identical types.
A marker node that takes the result of a child and marks it as a name
that can later be retrieved.
The node for performing an equi-select on a group of columns of the
child node.
A branch node for naturally joining two tables together.
A branch node for a non-correlated ANY or ALL sub-query evaluation.
The node for performing a simple indexed query on a single column of the
child node.
The node for evaluating a simple pattern search on a table which
includes a single left hand variable or constant, a pattern type (LIKE,
NOT LIKE or REGEXP), and a right hand constant (eg.
The node for performing a simple select operation on a table.
A QueryPlanNode with a single child.
A node for creating a table with a single row.
The node for performing a sort operation on the given columns of the
child node.
The node for finding a subset and renaming the columns of the results in
the child node.
A node element of a query plan tree.
The response to a query executed via the 'execQuery' method in the
DatabaseInterface interface.
An interface that allows for the inspection and repair of the raw data
in a file.
An interface that represents a reference to a object that isn't stored in
main memory.
This is an implementation of a Table that references a DataTable as its
parent.
An interface that links with a Regex library.
Utilities for parsing a ResultSet and outputing it in different forms.
A container class that holds a part of a result set.
An implementation of a javax.swing.table.TableModel that updates itself from
a scrollable java.sql.ResultSet source.
Interface that is implemented by all Root tables.
Represents a row of data to be added into a table.
This enumeration allows for access to a tables rows.
An implementation of StoreDataAccessor that scatters the addressible
data resource across multiple files in the file system.
Statement container that handles the CREATE SCHEMA and DROP SCHEMA
statements.
A definition of a schema.
Search expression is a form of an Expression that is split up into
component parts that can be easily formed into a search query.
This object stores the result of a given search.
Logic for interpreting an SQL SELECT statement.
An object that represents a range of values to select from a list.
Represents a complex normalized range of a list.
Represents a base class for a mechanism to select ranges from a given set.
Represents a column selected to be in the output of a select statement.
A statement tree for creating and dropping sequence generators.
The SQL SET statement.
An implementation of UserTerminal that uses the shell terminal via
System.in and System.out.
Statement that handles SHOW and DESCRIBE sql commands.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
A RowEnumeration implementation that represents a sequence of rows that
can be referenced in incremental order between 0 and row_count (exclusive).
A simple convenience interface for querying a MutableTableDataSource
instance.
An simple implementation of Transaction that provides various facilities for
implementing a Transaction object on a number of MasterTableDataSource
tables.
Provides various sort utilities for a list of objects that implement
Comparable.
An SQLException that signifies username/password authentication failed.
Represents an SQL Query to the database.
An object used to execute SQL queries against a given DatabaseConnection
object.
A JDBC independant type definition list.
This class contains a number of standard messages that are displayed
throughout the operation of the database.
Provides a set of useful utility functions to use by all the
interpretted statements.
A cache that maintains a serialized set of StatementTree objects that can
be deserialized on demand.
An error that is thrown when there is erronious information in a statement.
A serializable container class for a parsed query language statement.
An complex object that is to be contained within a StatementTree object.
An object that is used to store and update various stats.
A store is a resource where areas can be allocated and freed to store
objects.
An object that is streamable (such as a long binary object, or
a long string object).
Represents a response from the server for a section of a streamable object.
A RandomAccessFile that acts as an OutputStream, and can also be read as an
InputStream.
An interface used by the engine to access and process strings.
A utility container class for holding a list of strings.
A concrete implementation of StringAccessor that uses a java.lang.String
object.
Various String utilities.
This object is a filter that sits atop a Table object.
Helper class for providing blocking behaviour on the AWT/Swing event
dispatcher thread without freezing up the user interface.
A stored procedure that backs up the entire database to the given directory
in the file system.
This is a definition for a table in the database.
This class provides very limited access to a Table object.
An object that encapsulates all row modification information about a table
when a change to the table is about to be committed.
A conglomerate of data that represents the contents of all tables in a
complete database.
This interface represents the source of data in a table.
An object that is a key part of Database.
A number of functions that are table set functions such as simple select
operations, joins, unions, sub-query operations, etc.
The event information of when a table is modified inside a transaction.
A name of a table and any associated referencing information.
An interface to an object that describes characteristics of a table based
object in the database.
A container object for the a table select expression, eg.
An implementation of TType for an expression array.
An implementation of TType for a binary block of data.
An implementation of TType for a boolean value.
Attaches to a DBSystem, and binds a TCP port and serves queries for JDBC
connections.
A TCP/IP socket server that opens a single port and allows JDBC clients
to connect through the port to talk with the database.
An implementation of TType for date objects.
This class represents a temporary table that is built from data that is
not related to any underlying DataTable object from the database.
An immutable object that represents a frame of time down to the
accuracy of a millisecond.
An implementation of TType for a java object of possibly defined type.
An implementation of TType that represents a NULL type.
An implementation of TType for a number.
A TObject is a strongly typed object in a database engine.
Describes the input token stream.
An implementation of TType for a query plan value.
An open transaction that manages all data access to the
TableDataConglomerate.
Represents a constraint expression to check.
A group of columns as used by the constraint system.
Represents a reference from a group of columns in one table to a group of
columns in another table.
Thrown when a transaction error happens.
A listener that is notified of table modification events made by a
transaction, both immediately inside a transaction and when a transaction
commits.
A class that provides information and global functions for the transaction
layer in the engine.
A trigger event represents a high level action that occured in the
database.
A listener that is notified when the trigger being listened to is fired.
A listener that can listen for high layer trigger events.
An implementation of TType for a String.
A TType object represents a type in a database engine.
The possible types used in the database.
Utility for converting to and from 'Types' objects.
The instance class that stores all the information about an update
statement for processing.
Encapsulates the information about a single user logged into the system.
An exception that is thrown when the user is not permitted to perform a
certain action.
Handler for User commands for creating, altering and dropping user accounts
in the database.
A class that manages the list of users connected to the engine.
An interface that represents a terminal that is asked questions in human
and machine understandable terms, and sends answers.
Various utility methods for the iterpreter.
A MasterTableDataSource that uses IndexStore and VariableSizeDataStore as
its backing mechanism for representing the table structure in a file on
disk.
A MasterTableDataSource that is backed by a non-shared com.mckoi.store.Store
object.
This represents a column name that may be qualified.
An interface to resolve a variable name to a constant object.
Provides a mechanism for storing variable length data in a file which can
quickly be indexed via a reference number.
A ViewDef object is a definition of a view stored in the database.
Handler for creating and dropping views in the database.
A DatabaseConnection view manager.
A VirtualTable is a representation of a table whose rows are actually
physically stored in another table.