# All Classes

All Classes Interface Summary Class Summary Exception Summary Error Summary
AbstractAggregateFunction: Provides convenience methods for handling aggregate functions (functions that are evaluated over a grouping set).
AbstractBlockIntegerList: An implementation of a list of integer values that are stored across an array of blocks.
AbstractDataTable: This is the abstract class implemented by a DataTable like table.
AbstractDBConfig: An abstract implementation of DBConfig.
AbstractFunction: An abstract implementation of Function.
AbstractJDBCDatabaseInterface: An abstract implementation of JDBCDatabaseInterface that provides a connection between a single DatabaseConnection and a DatabaseInterface implementation.
AbstractQueryContext: An abstract implementation of QueryContext
AbstractStore: Provides an abstract implementation of Store.
AlterTable: Logic for the ALTER TABLE SQL statement.
AlterTableAction: Represents an action in an ALTER TABLE SQL statement.
Area: An interface for access the contents of an area of a store.
AreaWriter: The interface used for setting up an area initially in a store.
AsciiReader: A java.io.Reader implementation that wraps around an ascii input stream (8-bit per char stream).
Assignment: An assignment from a variable to an expression.
BigNumber: Extends BigDecimal to allow a number to be positive infinity, negative infinity and not-a-number.
BinaryToUnicodeReader: A Reader implementation that wraps around a unicode encoded input stream that encodes each unicode character as 2 bytes.
BlindSearch: This is a scheme that performs a blind search of a given set.
BlobAccessor: An interface that provides access to basic information about a BLOB so that we may compare BLOBs implemented in different ways.
BlobRef: A lightweight interface that is a reference to a blob in a BlobStore.
BlobStoreInterface: A very restricted interface for accessing a blob store.
BlockIntegerList: An implementation of AbstractBlockIntegerList that stores all int values in blocks that are entirely stored in main memory.
BlockIntegerList.IntArrayListBlock: The block that contains the actual int values of the list.
ByColumn: Object used to represent a column in the 'order by' and 'group by' clauses of a select statement.
ByteArrayUtil: Static utilities for byte arrays.
ByteBuffer: A wrapper for an array of byte[].
ByteLongObject: A byte array that can be transferred between the client and server.
Cache: Represents a cache of Objects.
Call: A statement that calls a procedure, and returns a resultant table.
Caster: Methods to choose and perform casts from database type to Java types.
CastHelper: Various utility methods for helping to cast a Java object to a type that is conformant to an SQL type.
CellBufferOutputStream: This is a ByteArrayOutputStream that allows access to the underlying byte array.
CellInput
ClobRef: A reference to a large character object in the database.
CollatedBaseSearch: An implementation of SelectableScheme that is based on some collated set of data.
ColumnDef: Represents a column definition (description).
ColumnDescription: This is a description of a column and the data it stores.
CommandLine: Used to parse a command-line.
Compact: Statement that handles COMPACT sql command.
CompleteTransaction: This represents either a COMMIT or ROLLBACK SQL command.
CompositeTable: A composite of two or more datasets used to implement UNION, INTERSECTION, and DIFFERENCE.
ConnectionTriggerManager: A trigger manager on a DatabaseConnection that maintains a list of all triggers set in the database, and the types of triggers they are.
ConstraintDef: Represents a constraint definition (description) for a table.
CorrelatedVariable: A wrapper for a variable in a sub-query that references a column outside of the current query.
CreateTable: A parsed state container for the 'create' statement.
CreateTrigger: A parsed state container for the 'CREATE TRIGGER' statement.
Database: The representation of a single database in the system.
DatabaseCallBack: An interface that is input to the DatabaseInterface as a way to be notified of event information from inside the database.
DatabaseConnection: An object that represents a connection to a Database.
DatabaseConnection.CallBack: Call back interface for events that occur within the connection instance.
DatabaseConstants: Contant static values that determine several parameters of the database operation.
DatabaseConstraintViolationException: A database exception that represents a constraint violation.
DatabaseException: Exception thrown where various problems occur within the database.
DatabaseInterface: The interface with the Database whether it be remotely via TCP/IP or locally within the current JVM.
DatabaseProcedure: This interface represents a database procedure that is executed on the server side.
DatabaseQueryContext: An implementation of a QueryContext based on a DatabaseConnection object.
DatabaseSystem: This class provides information about shared resources available for the entire database system running in this VM.
DataFileConvertTool: A tool for converting between different versions of the database file system.
DataIndexDef: Represents index meta-information on a table.
DataIndexSetDef: Represents the meta-data for a set of indexes of a table.
DataTable: DataTable is a wrapper for a MutableTableDataSource that fits into the query hierarchy level.
DataTableColumnDef: All the information regarding a column in a table.
DataTableDef: A definition of a table.
DataTableFilter: This object sits on top of a DataTable object filtering out certain types of calls.
DBConfig: A container object of configuration details of a database system.
DBConglomerateDiagTool: An interactive tool for diagnosing the contents of a TableDataConglomerate object.
DBConglomerateRepairTool: A command line repair tool for repairing a corrupted conglomerate.
DBController: An object that provides methods for creating and controlling database systems in the current JVM.
DBSystem: An object used to access and control a single database system running in the current JVM.
Debug: Deprecated. use DebugLogger implementations instead.
DebugLogger: An interface for logging errors, warnings, messages, and exceptions in the Mckoi system.
DefaultDataTable: This represents a default implementation of a DataTable.
DefaultDBConfig: Implements a default database configuration that is useful for setting up a database.
DefaultDebugLogger: A default implementation of DebugLogger that logs messages to a PrintWriter object.
DefaultLocalBootable: A bootable object that filters through to a JDBCDatabaseInterface but is thread-safe and multi-threaded.
Delete: Logic for the DELETE FROM SQL statement.
DropTable: The logic of the 'DROP TABLE' SQL command.
DropTrigger: A parsed state container for the 'DROP TRIGGER' statement.
Expression: An expression that can be evaluated in a statement.
ExpressionPreparer: An interface used to prepare an Expression object.
FilterTable: A table that is a filter for another table.
FixedRecordList: A structure that provides a fast way to read and write fixed sized nodes in a Store object.
FixedSizeDataStore: A file format that allows for the very quick retreival of data that is stored within it.
FromClause: A container for the From clause of a select statement.
FromTableDef: Describes a single table declaration in the from clause of a table expression (SELECT).
FromTableDirectSource: An implementation of FromTableInterface that wraps around an TableName/AbstractDataTable object.
FromTableInterface: 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.
FromTableSubQuerySource: An implementation of FromTableInterface that wraps around a TableSelectExpression object as a sub-query source.
Function: Represents a function that is part of an expression to be evaluated.
Function: A handler for defining and dropping functions.
FunctionDef: A definition of a function including its name and parameters.
FunctionFactory: A factory that generates Function objects given a function name and a set of expression's that represent parameters.
FunctionInfo: Meta information about a function.
FunctionLookup: An interface that resolves and generates a Function objects given a FunctionDef object.
FunctionTable: A table that has a number of columns and as many rows as the refering table.
GeneralFormatter: This class provides several static convenience functions for formatting various types of information such as a time frame.
GeneralParser: This class provides several static convenience functions for parsing various types of character sequences.
GrantManager: A class that manages the grants on a database for a given database connection and user.
GroupResolver: Similar to VariableResolver, this method is used by grouping Functions to find information about the current group being evaluated (used for evaluating aggregate functions).
GTPrivMapDataSource: A GTDataSource that maps a Privs 11-bit set to strings that represent the priv in human understandable string.
GTSQLTypeInfoDataSource: A GTDataSource that models all SQL types that are available.
HashMapList: A HashMap that maps from a source to a list of items for that source.
HeapStore: An implementation of the Store interface that persists information in the volatile JVM heap memory.
IndexComparator: A comparator that is used within BlockIntegerList that compares two int values which are indices to data that is being compared.
IndexSet: A set of list of indexes.
IndexStore: A class that manages the storage of a set of transactional index lists in a way that is fast to modify.
Insert: The instance class that stores all the information about an insert statement for processing.
InsertSearch: This is a SelectableScheme similar in some ways to the binary tree.
IntegerIterator: An iterator for a list of integer's.
IntegerListBlockInterface: A block of an AbstractBlockIntegerList.
IntegerListInterface: An interface for querying and accessing a list of primitive integers.
IntegerVector: Similar to the Vector class, except this can only store integer values.
JavaRegex: A bridge to the internal Java regular expression library that was introduced in Java 1.4.
JDBCDatabaseInterface: An implementation of jdbc.DatabaseInterface on the server-side.
JDBCDriver: Instance class that registers the mckoi JDBC driver with the JDBC Driver Manager.
JDBCQueryTool: A graphical interactive SQL query tool that allows for queries to be executed to a JDBC driver.
JDBCScriptTool: A tool that reads an input SQL script and output information for the result either to an output file or through System.out.
JoinedTable: A Table that represents the result of one or more other tables joined together.
JoiningSet: Used in TableSet to describe how we naturally join the tables together.
JoiningSet.JoinPart
JournalledFileStore: An implementation of AbstractStore that persists to an underlying data format via a robust journalling system that supports check point and crash recovery.
LengthMarkedBufferedInputStream: Reads a command block on the underlying stream that is constrained by a length marker preceeding the command.
LocalBootable: An interface that is implemented by an object that boots up the database.
Lock: This is a lock on a table in the LockingMechanism class.
LockHandle: This represents a handle for a series of locks that a query has over the tables in a database.
LockingMechanism: This class represents a model for locking the tables in a database during any sequence of concurrent read/write accesses.
Log: A log file/stream that logs some information generated by the system.
LoggingBufferManager: 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).
LoggingBufferManager.StoreDataAccessorFactory: A factory interface for creating StoreDataAccessor objects from resource names.
LogWriter: A Writer that writes information to a log file that archives old log entries when it goes above a certain size.
Lvl: Debug level static values.
MckoiConnection: Wraps a Connection and provides Mckoi specific extensions that are outside the JDBC specification.
McKoiDBMain: The start point of the Mckoi SQL database server.
MConnection: JDBC implementation of the connection object to a Mckoi database.
MDatabaseMetaData: An implementation of JDBC's DatabaseMetaData.
MDriver: JDBC implementation of the driver for the Mckoi database.
Misc: Misc statements that I couldn't be bothered to roll a new Statement class for.
MResultSet: Implementation of a ResultSet.
MResultSetMetaData: An implementation of JDBC's ResultSetmetaData.
MSQLException: SQLException used by the McKoi database engine.
MutableArea: An interface for an area that can be modified.
MutableTableDataSource: A mutable data source that allows for the addition and removal of rows.
NaturallyJoinedTable: A table that is the cartesian product of two tables.
NoOp: A no operation statement.
NullObject: Deprecated. do not use.
ObjectTransfer: Provides static methods for transfering different types of objects over a Data input/output stream.
ObjectTranslator: This object compliments ObjectTransfer and provides a method to translate any object into a type the database engine can process.
Operator: An operator for an expression.
PagedInputStream: An implementation of InputStream that reads data from an underlying representation in fixed sized pages.
ParameterSubstitution: An object that represents a constant value that is to be lately binded to a constant value in an Expression.
ParseException: This exception is thrown when parse errors are encountered.
PatternSearch: This is a static class that performs the operations to do a pattern search on a given column of a table.
Planner: Various methods for forming query plans on SQL queries.
Privileges: A set of privileges to grant a user for an object.
PrivManager: Handler for grant/revoke queries for setting up grant information in the database.
ProcedureConnection: An interface for accessing a database connection inside a stored procedure.
ProcedureException: An exception that is generated from a stored procedure when some erronious condition occurs.
ProcedureManager: A DatabaseConnection procedure manager.
ProcedureName: The name of a procedure as understood by a ProcedureManager.
ProtocolConstants: Constants used in the JDBC database communication protocol.
Query: Encapsulates the information in a query to the database.
QueryAgent: A class that is an agent for queries from the client environment to the server.
QueryContext: Facts about a particular query including the root table sources, user name of the controlling context, sequence state, etc.
QueryPlan: Various helper methods for constructing a plan tree, and the plan node implementations themselves.
QueryPlan.BranchQueryPlanNode: A QueryPlanNode that is a branch with two child nodes.
QueryPlan.CachePointNode: A cache point node that only evaluates the child if the result can not be found in the cache with the given unique id.
QueryPlan.CompositeNode: A branch node for performing a composite function on two child nodes.
QueryPlan.ConstantSelectNode: The node for evaluating an expression that contains entirely constant values (no variables).
QueryPlan.CreateFunctionsNode: The node for merging the child node with a set of new function columns over the entire result.
QueryPlan.DistinctNode: The node for performing a distinct operation on the given columns of the child node.
QueryPlan.EquiJoinNode: A branch node for equi-joining two tables together given two sets of columns.
QueryPlan.ExhaustiveSelectNode: The node for performing a exhaustive select operation on the child node.
QueryPlan.FetchTableNode: The node for fetching a table from the current transaction.
QueryPlan.FetchViewNode: The node that fetches a view from the current connection.
QueryPlan.FunctionalSelectNode: The node for performing a functional select operation on the child node.
QueryPlan.GroupNode: The node for performing a grouping operation on the columns of the child node.
QueryPlan.JoinNode: A branch node for a non-equi join between two tables.
QueryPlan.LeftOuterJoinNode: A branch node for a left outer join.
QueryPlan.LogicalUnionNode: A branch node for a logical union of two tables of identical types.
QueryPlan.MarkerNode: A marker node that takes the result of a child and marks it as a name that can later be retrieved.
QueryPlan.MultiColumnEquiSelectNode: The node for performing an equi-select on a group of columns of the child node.
QueryPlan.NaturalJoinNode: A branch node for naturally joining two tables together.
QueryPlan.NonCorrelatedAnyAllNode: A branch node for a non-correlated ANY or ALL sub-query evaluation.
QueryPlan.RangeSelectNode: The node for performing a simple indexed query on a single column of the child node.
QueryPlan.SimplePatternSelectNode: 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.
QueryPlan.SimpleSelectNode: The node for performing a simple select operation on a table.
QueryPlan.SingleQueryPlanNode: A QueryPlanNode with a single child.
QueryPlan.SingleRowTableNode: A node for creating a table with a single row.
QueryPlan.SortNode: The node for performing a sort operation on the given columns of the child node.
QueryPlan.SubsetNode: The node for finding a subset and renaming the columns of the results in the child node.
QueryPlanNode: A node element of a query plan tree.
QueryResponse: The response to a query executed via the 'execQuery' method in the DatabaseInterface interface.
RawDiagnosticTable: An interface that allows for the inspection and repair of the raw data in a file.
Ref: An interface that represents a reference to a object that isn't stored in main memory.
ReferenceTable: This is an implementation of a Table that references a DataTable as its parent.
RegexLibrary: An interface that links with a Regex library.
ResultOutputUtil: Utilities for parsing a ResultSet and outputing it in different forms.
ResultPart: A container class that holds a part of a result set.
ResultSetTableModel: An implementation of a javax.swing.table.TableModel that updates itself from a scrollable java.sql.ResultSet source.
RootTable: Interface that is implemented by all Root tables.
RowData: Represents a row of data to be added into a table.
RowEnumeration: This enumeration allows for access to a tables rows.
ScatteringStoreDataAccessor: An implementation of StoreDataAccessor that scatters the addressible data resource across multiple files in the file system.
Schema: Statement container that handles the CREATE SCHEMA and DROP SCHEMA statements.
SchemaDef: A definition of a schema.
SearchExpression: Search expression is a form of an Expression that is split up into component parts that can be easily formed into a search query.
SearchResults: This object stores the result of a given search.
Select: Logic for interpreting an SQL SELECT statement.
SelectableRange: An object that represents a range of values to select from a list.
SelectableRangeSet: Represents a complex normalized range of a list.
SelectableScheme: Represents a base class for a mechanism to select ranges from a given set.
SelectColumn: Represents a column selected to be in the output of a select statement.
Sequence: A statement tree for creating and dropping sequence generators.
Set: The SQL SET statement.
ShellUserTerminal: An implementation of UserTerminal that uses the shell terminal via System.in and System.out.
Show: Statement that handles SHOW and DESCRIBE sql commands.
SimpleCharStream: An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
SimpleRowEnumeration: A RowEnumeration implementation that represents a sequence of rows that can be referenced in incremental order between 0 and row_count (exclusive).
SimpleTableQuery: A simple convenience interface for querying a MutableTableDataSource instance.
SimpleTransaction: An simple implementation of Transaction that provides various facilities for implementing a Transaction object on a number of MasterTableDataSource tables.
SortUtil: Provides various sort utilities for a list of objects that implement Comparable.
SQL
SQLConstants
SQLLoginException: An SQLException that signifies username/password authentication failed.
SQLQuery: Represents an SQL Query to the database.
SQLQueryExecutor: An object used to execute SQL queries against a given DatabaseConnection object.
SQLTokenManager
SQLTypes: A JDBC independant type definition list.
StandardMessages: This class contains a number of standard messages that are displayed throughout the operation of the database.
Statement: Provides a set of useful utility functions to use by all the interpretted statements.
StatementCache: A cache that maintains a serialized set of StatementTree objects that can be deserialized on demand.
StatementException: An error that is thrown when there is erronious information in a statement.
StatementTree: A serializable container class for a parsed query language statement.
StatementTreeObject: An complex object that is to be contained within a StatementTree object.
Stats: An object that is used to store and update various stats.
Store: A store is a resource where areas can be allocated and freed to store objects.
StreamableObject: An object that is streamable (such as a long binary object, or a long string object).
StreamableObjectPart: Represents a response from the server for a section of a streamable object.
StreamFile: A RandomAccessFile that acts as an OutputStream, and can also be read as an InputStream.
StringAccessor: An interface used by the engine to access and process strings.
StringListBucket: A utility container class for holding a list of strings.
StringObject: A concrete implementation of StringAccessor that uses a java.lang.String object.
StringUtil: Various String utilities.
SubsetColumnTable: This object is a filter that sits atop a Table object.
SwingBlockUtil: Helper class for providing blocking behaviour on the AWT/Swing event dispatcher thread without freezing up the user interface.
SystemBackup: A stored procedure that backs up the entire database to the given directory in the file system.
Table: This is a definition for a table in the database.
TableAccessState: This class provides very limited access to a Table object.
TableCommitModificationEvent: An object that encapsulates all row modification information about a table when a change to the table is about to be committed.
TableDataConglomerate: A conglomerate of data that represents the contents of all tables in a complete database.
TableDataSource: This interface represents the source of data in a table.
TableDescriptions: An object that is a key part of Database.
TableFunctions: A number of functions that are table set functions such as simple select operations, joins, unions, sub-query operations, etc.
TableModificationEvent: The event information of when a table is modified inside a transaction.
TableName: A name of a table and any associated referencing information.
TableQueryDef: An interface to an object that describes characteristics of a table based object in the database.
TableSelectExpression: A container object for the a table select expression, eg.
TArrayType: An implementation of TType for an expression array.
TBinaryType: An implementation of TType for a binary block of data.
TBooleanType: An implementation of TType for a boolean value.
TCPJDBCServer: Attaches to a DBSystem, and binds a TCP port and serves queries for JDBC connections.
TCPServer: A TCP/IP socket server that opens a single port and allows JDBC clients to connect through the port to talk with the database.
TDateType: An implementation of TType for date objects.
TemporaryTable: This class represents a temporary table that is built from data that is not related to any underlying DataTable object from the database.
TimeFrame: An immutable object that represents a frame of time down to the accuracy of a millisecond.
TJavaObjectType: An implementation of TType for a java object of possibly defined type.
TNullType: An implementation of TType that represents a NULL type.
TNumericType: An implementation of TType for a number.
TObject: A TObject is a strongly typed object in a database engine.
Token: Describes the input token stream.
TokenMgrError
TQueryPlanType: An implementation of TType for a query plan value.
Transaction: An open transaction that manages all data access to the TableDataConglomerate.
Transaction.CheckExpression: Represents a constraint expression to check.
Transaction.ColumnGroup: A group of columns as used by the constraint system.
Transaction.ColumnGroupReference: Represents a reference from a group of columns in one table to a group of columns in another table.
TransactionException: Thrown when a transaction error happens.
TransactionModificationListener: A listener that is notified of table modification events made by a transaction, both immediately inside a transaction and when a transaction commits.
TransactionSystem: A class that provides information and global functions for the transaction layer in the engine.
TriggerEvent: A trigger event represents a high level action that occured in the database.
TriggerListener: A listener that is notified when the trigger being listened to is fired.
TriggerListener: A listener that can listen for high layer trigger events.
TStringType: An implementation of TType for a String.
TType: A TType object represents a type in a database engine.
Types: The possible types used in the database.
TypeUtil: Utility for converting to and from 'Types' objects.
UpdateTable: The instance class that stores all the information about an update statement for processing.
User: Encapsulates the information about a single user logged into the system.
UserAccessException: An exception that is thrown when the user is not permitted to perform a certain action.
UserManager: Handler for User commands for creating, altering and dropping user accounts in the database.
UserManager: A class that manages the list of users connected to the engine.
UserTerminal: An interface that represents a terminal that is asked questions in human and machine understandable terms, and sends answers.
Util: Various utility methods for the iterpreter.
V1MasterTableDataSource: A MasterTableDataSource that uses IndexStore and VariableSizeDataStore as its backing mechanism for representing the table structure in a file on disk.
V2MasterTableDataSource: A MasterTableDataSource that is backed by a non-shared com.mckoi.store.Store object.
Variable: This represents a column name that may be qualified.
VariableResolver: An interface to resolve a variable name to a constant object.
VariableSizeDataStore: Provides a mechanism for storing variable length data in a file which can quickly be indexed via a reference number.
ViewDef: A ViewDef object is a definition of a view stored in the database.
ViewManager: Handler for creating and dropping views in the database.
ViewManager: A DatabaseConnection view manager.
VirtualTable: A VirtualTable is a representation of a table whose rows are actually physically stored in another table.