All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| Abs |
Implementation of the ABS(x) SQL function, computes the absolute
value of a single argument.
|
| AggregateFunction |
This class provides the general abstraction for aggregate functions.
|
| AnalyzeCommand |
This Command class represents the ANALYZE SQL command, which
analyzes a table's internal data and updates its cached statistics to be as
up-to-date as possible.
|
| ArcCos |
Implementation of the ACOS(x) SQL function, computes the
arc-cosine of a single argument.
|
| ArcSin |
Implementation of the ASIN(x) SQL function, computes the
arc-sine of a single argument.
|
| ArcTan |
Implementation of the ATAN(x) SQL function, computes the
arc-tangent of a single argument.
|
| ArcTan2 |
Implementation of the ATAN2(y, x) SQL function, computes the
arc-tangent of two arguments.
|
| ArithmeticOperator |
This class implements simple binary arithmetic operations.
|
| ArithmeticOperator.Type |
This enum specifies the arithmetic operations that this class can provide.
|
| ArrayUtil |
Some helpful utility operations for working with arrays.
|
| Avg |
Implementation of the AVG(x) SQL aggregate function, computes the
average of its inputs.
|
| AvgDistinct |
Implementation of the AVG(DISTINCT x) SQL aggregate function,
computes the average of its inputs.
|
| BasicIndexManager |
|
| BeginTransactionCommand |
This class represents a command that starts a transaction, such as
BEGIN, BEGIN WORK, or START TRANSACTION.
|
| BooleanFlagValidator |
This validator handles properties that are Boolean flags.
|
| BooleanOperator |
This class provides the standard Boolean logical operators AND, OR, and NOT,
for two or more terms (or exactly one term, in the case of NOT).
|
| BooleanOperator.Type |
This enumeration specifies the different kinds of Boolean operators that
this class can implement.
|
| BufferManager |
The buffer manager reduces the number of disk IO operations by managing an
in-memory cache of data pages.
|
| BufferManager.CachedPageInfo |
This helper class keeps track of a data page that is currently cached.
|
| BufferManager.SessionPinCount |
This helper class records the pin-count of a data page as imposed by a
given session, so that we can forcibly release the session's pins after
each command the session completes.
|
| BufferManagerObserver |
This interface allows other classes to respond to operations performed by
the BufferManager. |
| Ceil |
Implementation of the CEIL(x) / CEILING(x) SQL function,
computes the smallest whole number larger than the argument.
|
| ClientHandlerThread |
This class handles a connection from a single client to the database
server.
|
| CmdLineArgs |
|
| Coalesce |
Implementation of the COALESCE(a, b, ...) SQL function, returns
the first non-NULL argument.
|
| ColumnInfo |
Basic information about a table column, including its name and SQL type.
|
| ColumnName |
This class represents a column name that appears in an SQL expression.
|
| ColumnRefs |
This class represents a set of columns in a schema by specifying the
indexes of the columns in the set.
|
| ColumnStats |
This class holds some useful statistics for a specific column.
|
| ColumnStatsCollector |
|
| ColumnType |
The type of a single column in a relation.
|
| ColumnValue |
This expression class represents the value of a tuple column.
|
| Command |
Abstract base-class for all commands that NanoDB supports.
|
| Command.Type |
Commands are either Data-Definition Language (DDL), Data-Manipulation
Language (DML), or utility commands.
|
| CommandEventListener |
This interface can be implemented by components that need to do processing
before and/or after a command is executed.
|
| CommandProperties |
This class holds properties that might contain additional details for a
command.
|
| CommandResult |
This class represents the result of executing a command against the
database.
|
| CommandState |
An enumeration indicating the current command's execution status.
|
| CommitTransactionCommand |
This class represents a command that commits a transaction, such as
COMMIT or COMMIT WORK.
|
| CompareOperator |
This class implements simple binary comparison operations.
|
| CompareOperator.Type |
This enumeration specifies the types of comparisons that can be
performed.
|
| Concat |
Implementation of the CONCAT(s1, s2, ...) SQL function,
concatenates two or more arguments as strings.
|
| ConstraintDecl |
Constraints may be specified at the table level, or they may be specified
on individual columns.
|
| ConstraintViolationException |
This exception is used to signal when a database constraint is violated.
|
| Cos |
Implementation of the COS(x) SQL function, computes the cosine of
a single argument.
|
| CostBasedJoinPlanner |
This planner implementation uses dynamic programming to devise an optimal
join strategy for the query.
|
| CostBasedJoinPlanner.JoinComponent |
This helper class is used to keep track of one "join component" in the
dynamic programming algorithm.
|
| Count |
Created by donnie on 12/6/13.
|
| CountAggregate |
This aggregate function can be used to compute both COUNT(...) and
COUNT(DISTINCT ...) aggregate functions.
|
| CountDistinct |
Created by donnie on 12/7/13.
|
| CountStar |
Created by donnie on 11/1/14.
|
| CrashCommand |
This command "crashes" the database by shutting it down immediately without
any proper cleanup or flushing of caches.
|
| CreateIndexCommand |
This command-class represents the CREATE INDEX DDL command.
|
| CreateTableCommand |
This command handles the CREATE TABLE DDL operation.
|
| CreateViewCommand |
This command-class represents the CREATE VIEW DDL command.
|
| DatabaseConstraintEnforcer |
This class enforces all database constraints on the database schema,
including NOT NULL constraints, primary key/unique constraints,
and foreign key constraints.
|
| DataFormatException |
This class represents runtime issues with data files not being in the
proper format, or other such issues occurring.
|
| DataPage |
This class provides the constants and operations necessary for manipulating
a data page within a heap file.
|
| DateTimeUtils |
Provides a number of utility operations for working with dates, times and
timestamps.
|
| DBFile |
This class provides page-level access to a database file, which contains
some kind of data utilized in a database system.
|
| DBFileReader |
This class provides the basic abilty to read a DBFile as a single
sequential file, obscuring the fact that it is actually broken into pages. |
| DBFileType |
This enumeration specifies the different types of data file that the
database knows about.
|
| DBFileWriter |
A subclass of DBFileReader, this class provides the basic ability
to read and write a DBFile as a single sequential file, obscuring
the fact that it is actually broken into pages. |
| DBPage |
This class represents a single page in a database file.
|
| DBPageID |
A class representing the unique identity of a DBPage, used as
a key for tracking pages in maps.
|
| DDLUtils |
This helper class provides some useful functions for constructing keys and
indexes and other details for tables that are being initialized.
|
| Definitions |
This class holds expression aliases and view definitions during query
planning.
|
| DeleteCommand |
This command object represents a top-level DELETE command issued
against the database.
|
| DeleteCommand.TupleRemover |
An implementation of the tuple processor interface used by the
DeleteCommand to delete each tuple. |
| DivideByZeroException |
This exception is thrown when an expression would cause a divide by zero.
|
| DropIndexCommand |
This command-class represents the DROP INDEX DDL command.
|
| DropTableCommand |
This Command class represents the DROP TABLE SQL command.
|
| DumpCommand |
An abstract base-class that holds the common implementation of the various
kinds of dump commands.
|
| DumpCommand.TupleExporter |
A tuple processor implementation used to dump each tuple.
|
| DumpIndexCommand |
This command object represents a DUMP INDEX command issued against
the database.
|
| DumpTableCommand |
This command object represents a DUMP TABLE command issued against
the database.
|
| Environment |
This class holds the environment for evaluating expressions that include
symbols.
|
| EvalStats |
This class holds statistics generated from a query evaluation operation,
such as the number of rows fetched and the total time to perform the
evaluation.
|
| EventDispatcher |
The event dispatcher notifies listeners when specific events occur within
the database, related to command execution and row processing operations.
|
| EventDispatchException |
|
| ExclusiveClient |
This class is used for starting the NanoDB database in "exclusive mode,"
where only a single client interacts directly with the database system.
|
| ExecutionException |
This exception is thrown when a fatal error occurs during command
execution.
|
| ExistsOperator |
This class implements the EXISTS (subquery) operator.
|
| ExitCommand |
This Command class represents the EXIT or QUIT SQL
commands.
|
| ExplainCommand |
This Command class represents the EXPLAIN SQL command, which prints
out details of how SQL DML statements will be evaluated.
|
| Expression |
This is the base type of all arithmetic and logical expressions that can be
represented in SQL commands.
|
| Expression.SymbolFinder |
This ExpressionProcessor implementation traverses an expression
and finds all symbols that appear within the expression.
|
| ExpressionException |
This exception is thrown when there is an error during the evaluation of an
expression.
|
| ExpressionProcessor |
This interface is used to implement scans or transformations of expression
trees by specifying what to do when entering or leaving each expression
node.
|
| FileManager |
This interface specifies all operations that file managers must provide.
|
| FileManagerImpl |
The File Manager provides unbuffered, low-level operations for working with
paged data files.
|
| FilePointer |
This class represents a pointer to a location within a database file.
|
| FileScanNode |
A select plan-node that scans a tuple file, checking the optional predicate
against each tuple in the file.
|
| FileSystemException |
This class represents errors that occur while opening, closing and
manipulating files.
|
| Floor |
Computes the largest whole number smaller than the argument.
|
| FlushCommand |
This command flushes all unwritten data from the buffer manager to disk.
|
| ForeignKeyColumnRefs |
This class represents a foreign key constraint between two tables in the
database.
|
| ForeignKeyValueChangeOption |
An enumeration specifying the options allowed for ON DELETE and
ON UPDATE actions for foreign keys.
|
| ForwardingOutputStream |
This class is a simple output-stream that can be used by a
PrintStream to buffer up printed output.
|
| FromClause |
This class represents a hierarchy of one or more base and derived relations
that produce the rows considered by SELECT clauses.
|
| FromClause.ClauseType |
This enumeration specifies the overall type of the FROM
clause.
|
| FromClause.JoinConditionType |
For FROM clauses that contain join expressions, this enumeration
specifies the kind of join-condition for each join expression.
|
| Function |
This is the root class of all kinds of functions in NanoDB.
|
| FunctionCall |
This class represents all kinds of function-call expressions, including
simple function calls, aggregate function calls, and table-returning
function calls.
|
| FunctionDirectory |
This class is a directory of all functions recognized within NanoDB,
including simple functions, aggregate functions and table functions.
|
| Greatest |
Returns the greatest value of all arguments.
|
| GroupAggregateNode |
This class provides the common functionality necessary for grouping and
aggregation.
|
| HashedGroupAggregateNode |
Implements grouping and aggregation by using hashing as a method to
identify groups.
|
| HashedTupleFile |
This interface extends the TupleFile interface, adding operations
that can be provided on files of tuples that are hashed on a specific key. |
| HeaderPage |
This class contains constants and basic functionality for accessing and
manipulating the contents of the header page of a heap table-file.
|
| HeapFilePageTuple |
|
| HeapTupleFile |
This class implements the TupleFile interface for heap files.
|
| HeapTupleFileManager |
This class provides high-level operations on heap tuple files.
|
| If |
Implements IF (cond, expr1, expr2).
|
| IfNull |
Implements IFNULL(expr1, expr2).
|
| IndexColumnRefs |
This class records that there is an index built on a particular set of
columns.
|
| IndexedTableManager |
This class provides an implementation of the TableManager interface
for tables that can have indexes and constraints on them. |
| IndexException |
This class represents errors that occur while manipulating indexes.
|
| IndexInfo |
This class is used to hold information about a single index in the
database.
|
| IndexManager |
This interface specifies all operations that are necessary for supporting
indexes in NanoDB.
|
| IndexType |
This enumeration represents the different kinds of indexes that NanoDB
supports, since different kinds of indexes facilitate different kinds of
lookups with different performance characteristics.
|
| IndexUpdater |
This class implements the RowEventListener interface to make sure
that all indexes on an updated table are kept up to date. |
| IndexUtils |
This class provides a number of very useful utility operations that make it
easier to create and work with indexes.
|
| InsertCommand |
This command object represents a top-level INSERT command issued
against the database.
|
| InsertCommand.TupleInserter |
An implementation of the tuple processor interface used by the
InsertCommand to insert tuples into a table, when the command is
of the form INSERT ... |
| InSubqueryOperator |
This class implements the expr IN (subquery) operator.
|
| IntegerValueValidator |
Validates an integer property value using a predicate; if the value cannot
be cast to an integer or the predicate returns false, then the specified
error message will be reported.
|
| InteractiveClient |
This abstract class implements the basic functionality necessary for
providing an interactive SQL client.
|
| InvalidFilePointerException |
This exception class can be thrown when a file-pointer is discovered to be
invalid for some reason.
|
| InvalidSQLException |
This exception is used to signal when a SQL query contains a semantic error
that prevents its evaluation.
|
| InValuesOperator |
This class implements the expr IN (values) operator.
|
| IsNullOperator |
|
| JoinType |
An enumeration specifying the different types of join operation.
|
| KeyColumnRefs |
This class represents a primary key or other unique key, specifying the
indexes of the columns in the key.
|
| Least |
Returns the least value of all arguments.
|
| LiteralValue |
This expression class represents literal values.
|
| LogSequenceNumber |
This class represents a Log Sequence Number (LSN) in the write-ahead log.
|
| Max |
Created by donnie on 12/7/13.
|
| Min |
Created by donnie on 12/7/13.
|
| MinMaxAggregate |
This aggregate function can be used to compute either the minimum or the
maximum of a collection of values.
|
| NanoDBException |
This is the base-class of all exceptions specific to NanoDB functionality.
|
| NanoDBServer |
This class provides the entry-point operations for managing the database
server, and executing commands against it.
|
| NanoSQLBaseListener |
This class provides an empty implementation of NanoSQLListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods. |
| NanoSQLBaseVisitor<T> |
This class provides an empty implementation of NanoSQLVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods. |
| NanoSQLLexer |
|
| NanoSQLListener |
This interface defines a complete listener for a parse tree produced by
NanoSQLParser. |
| NanoSQLParser |
|
| NanoSQLParser.AnalyzeStmtContext |
|
| NanoSQLParser.BeginTxnStmtContext |
|
| NanoSQLParser.CascadeOptCascadeContext |
|
| NanoSQLParser.CascadeOptionContext |
|
| NanoSQLParser.CascadeOptRestrictContext |
|
| NanoSQLParser.CascadeOptSetNullContext |
|
| NanoSQLParser.CmdPropertiesContext |
|
| NanoSQLParser.ColConstraintForeignKeyContext |
|
| NanoSQLParser.ColConstraintNotNullContext |
|
| NanoSQLParser.ColConstraintPrimaryKeyContext |
|
| NanoSQLParser.ColConstraintUniqueContext |
|
| NanoSQLParser.ColRefNoTableContext |
|
| NanoSQLParser.ColRefTableContext |
|
| NanoSQLParser.ColRefWildcardNoTableContext |
|
| NanoSQLParser.ColRefWildcardTableContext |
|
| NanoSQLParser.ColTypeBigIntContext |
|
| NanoSQLParser.ColTypeCharContext |
|
| NanoSQLParser.ColTypeDateContext |
|
| NanoSQLParser.ColTypeDateTimeContext |
|
| NanoSQLParser.ColTypeDecimalContext |
|
| NanoSQLParser.ColTypeDoubleContext |
|
| NanoSQLParser.ColTypeFloatContext |
|
| NanoSQLParser.ColTypeIntContext |
|
| NanoSQLParser.ColTypeTimeContext |
|
| NanoSQLParser.ColTypeTimestampContext |
|
| NanoSQLParser.ColTypeVarCharContext |
|
| NanoSQLParser.ColumnConstraintContext |
|
| NanoSQLParser.ColumnRefContext |
|
| NanoSQLParser.ColumnTypeContext |
|
| NanoSQLParser.CommandContext |
|
| NanoSQLParser.CommandNoSemicolonContext |
|
| NanoSQLParser.CommandsContext |
|
| NanoSQLParser.CommitTxnStmtContext |
|
| NanoSQLParser.CrashStmtContext |
|
| NanoSQLParser.CreateIndexStmtContext |
|
| NanoSQLParser.CreateTableStmtContext |
|
| NanoSQLParser.DeleteStmtContext |
|
| NanoSQLParser.DropIndexStmtContext |
|
| NanoSQLParser.DropTableStmtContext |
|
| NanoSQLParser.DumpIndexStmtContext |
|
| NanoSQLParser.DumpTableStmtContext |
|
| NanoSQLParser.ExitStmtContext |
|
| NanoSQLParser.ExplainDeleteContext |
|
| NanoSQLParser.ExplainInsertContext |
|
| NanoSQLParser.ExplainSelectContext |
|
| NanoSQLParser.ExplainStmtContext |
|
| NanoSQLParser.ExplainUpdateContext |
|
| NanoSQLParser.ExprAddContext |
|
| NanoSQLParser.ExprAndContext |
|
| NanoSQLParser.ExprBetweenContext |
|
| NanoSQLParser.ExprColumnRefContext |
|
| NanoSQLParser.ExprCompareContext |
|
| NanoSQLParser.ExpressionContext |
|
| NanoSQLParser.ExpressionListContext |
|
| NanoSQLParser.ExprExistsContext |
|
| NanoSQLParser.ExprFunctionCallContext |
|
| NanoSQLParser.ExprIsNullContext |
|
| NanoSQLParser.ExprLikeContext |
|
| NanoSQLParser.ExprLiteralContext |
|
| NanoSQLParser.ExprMulContext |
|
| NanoSQLParser.ExprMultiColInSubqueryContext |
|
| NanoSQLParser.ExprNotContext |
|
| NanoSQLParser.ExprOneColInSubqueryContext |
|
| NanoSQLParser.ExprOneColInValuesContext |
|
| NanoSQLParser.ExprOrContext |
|
| NanoSQLParser.ExprParenContext |
|
| NanoSQLParser.ExprScalarSubqueryContext |
|
| NanoSQLParser.ExprSimilarToContext |
|
| NanoSQLParser.ExprUnarySignContext |
|
| NanoSQLParser.FlushStmtContext |
|
| NanoSQLParser.FromCrossJoinContext |
|
| NanoSQLParser.FromExprContext |
|
| NanoSQLParser.FromImplicitCrossJoinContext |
|
| NanoSQLParser.FromJoinOnContext |
|
| NanoSQLParser.FromJoinUsingContext |
|
| NanoSQLParser.FromNaturalJoinContext |
|
| NanoSQLParser.FromNestedSelectContext |
|
| NanoSQLParser.FromParensContext |
|
| NanoSQLParser.FromTableContext |
|
| NanoSQLParser.FromTableFunctionContext |
|
| NanoSQLParser.FunctionCallContext |
|
| NanoSQLParser.InsertStmtContext |
|
| NanoSQLParser.JoinTypeContext |
|
| NanoSQLParser.JoinTypeFullOuterContext |
|
| NanoSQLParser.JoinTypeInnerContext |
|
| NanoSQLParser.JoinTypeLeftOuterContext |
|
| NanoSQLParser.JoinTypeRightOuterContext |
|
| NanoSQLParser.LiteralDecimalContext |
|
| NanoSQLParser.LiteralFalseContext |
|
| NanoSQLParser.LiteralIntegerContext |
|
| NanoSQLParser.LiteralIntervalContext |
|
| NanoSQLParser.LiteralNullContext |
|
| NanoSQLParser.LiteralStringContext |
|
| NanoSQLParser.LiteralTrueContext |
|
| NanoSQLParser.LiteralValueContext |
|
| NanoSQLParser.OptimizeStmtContext |
|
| NanoSQLParser.OrderByExprContext |
|
| NanoSQLParser.RollbackTxnStmtContext |
|
| NanoSQLParser.SelectStmtContext |
|
| NanoSQLParser.SelectValueContext |
|
| NanoSQLParser.SetPropStmtContext |
|
| NanoSQLParser.ShowPropsStmtContext |
|
| NanoSQLParser.ShowSystemStatsStmtContext |
|
| NanoSQLParser.ShowTablesStmtContext |
|
| NanoSQLParser.ShowTableStatsStmtContext |
|
| NanoSQLParser.TableColDeclContext |
|
| NanoSQLParser.TableConstraintContext |
|
| NanoSQLParser.TblConstraintForeignKeyContext |
|
| NanoSQLParser.TblConstraintPrimaryKeyContext |
|
| NanoSQLParser.TblConstraintUniqueContext |
|
| NanoSQLParser.UpdateStmtContext |
|
| NanoSQLParser.VerifyStmtContext |
|
| NanoSQLTranslator |
This class translates NanoSQL parse trees generated by the ANTLR4 grammar
into the corresponding hierarchy of Command and Expression
objects used by the server for command execution. |
| NanoSQLVisitor<T> |
This interface defines a complete generic visitor for a parse tree produced
by NanoSQLParser. |
| NegateOperator |
This class implements unary negation.
|
| NestedLoopJoinNode |
This plan node implements a nested-loop join operation, which can support
arbitrary join conditions but is also the slowest join implementation.
|
| NoCopyByteArrayOutputStream |
This class is a simple extension of Java's ByteArrayOutputStream that
exposes the internal buffer without having to make a copy of it via the
normal ByteArrayOutputStream.toByteArray() method.
|
| Null |
This class provides a type to associate with NULL literal values.
|
| NullIf |
Implements NULLIF(cond, expr).
|
| OptimizeCommand |
This Command class represents the OPTIMIZE SQL command, which
optimizes a table's representation (along with any indexes) to improve access
performance and space utilization.
|
| OrderByExpression |
This class represents an expression that results are ordered by, as well as
whether the order is ascending or descending.
|
| PageReader |
This class facilitates sequences of read operations against a single
DBPage object, by providing "position" state that is also updated
after each read is performed. |
| PageTuple |
This class is a partial implementation of the Tuple interface that
handles reading and writing tuple data against a DBPage object. |
| PageWriter |
This class extends the PageReader class to provide write operations
as well as read operations. |
| Pair |
A simple read-only wrapper-class for holding two values.
|
| ParseUtil |
This helper class parses a string into a SQL operation using the NanoSQL
parser.
|
| PerformanceCounters |
This class provides a basic performance-counter mechanism that can be used
concurrently from many different threads.
|
| Pinnable |
This interface provides the basic "pin" and "unpin" operations that
pinnable objects need to provide.
|
| PlanCost |
This class holds a collection of values that represent the cost of an
operation against the database.
|
| Planner |
This interface specifies the common entry-point for all query
planner/optimizer implementations.
|
| PlannerClassValidator |
This class validates the query-planner class name by making sure the
specified class actually derives from Planner, and that it may
be instantiated via a no-argument constructor. |
| PlanNode |
The base class of all query execution plan nodes.
|
| PlanUtils |
A collection of helpful utilities that can be used for generating,
analyzing and manipulating query execution plans.
|
| Pow |
Returns the first argument, raised to the second argument power.
|
| PredicateUtils |
A collection of helpful utilities that can be used for generating,
analyzing and manipulating predicates.
|
| PrettyPrintTools |
Various methods to use for pretty-printing, such as delimiters, padding, and
such.
|
| PrettyTuplePrinter |
This implementation of the tuple-processor interface prints out the schema
and the tuples produced by the SELECT statement in a cooler,
prettier fashion.
|
| ProjectNode |
PlanNode representing the SELECT clause in a SQL query.
|
| PropertyException |
This exception is thrown when an attempt is made to write to a read-only
property.
|
| PropertyObserver |
An interface that components can implement to be notified of changes to
property-values during system operation.
|
| PropertyReader |
This class provides helper operations for reading typed properties out of
Java Properties files, or out of the Java environment.
|
| PropertyRegistry |
This is the central location where all properties exposed by the database
can be registered and accessed.
|
| PropertyValidator |
|
| QueryCommand |
This class represents all SQL query commands, including SELECT,
INSERT, UPDATE, and DELETE.
|
| QueryCommand.Type |
Typesafe enumeration of query-command types.
|
| QueryEvaluator |
|
| QueryUtils |
|
| ReadPerfCounter |
Returns the current value of the specified performance counter.
|
| RecoveryInfo |
This class holds information necessary for the WALManager to perform
recovery processing, such as the LSNs to scan for redo/undo processing, and
the set of incomplete transactions. |
| RegexFileFilter |
This class provides a simple regex-based file filter for use with
File.listFiles(java.io.FileFilter).
|
| RenameNode |
This plan-node implements the Rename relational algebra operation, for
either renaming a table in a query, or assigning a table-name to a derived
relation.
|
| ResetPerfCounter |
Resets the specified performance counter, and returns the old value.
|
| RollbackTransactionCommand |
This class represents a command that rolls back a transaction, such as
ROLLBACK or ROLLBACK WORK.
|
| Round |
Computes the whole number that is closest to the argument.
|
| RowEventListener |
This interface can be implemented by components that need to do processing
before and/or after a row is inserted, updated, or deleted.
|
| ScalarFunction |
This class represents functions that return a scalar value.
|
| ScalarSubquery |
This class represents a scalar subquery embedded in another query's
predicate.
|
| Schema |
A schema is an ordered collection of column names and associated types.
|
| Schema.IndexedColumnInfo |
This helper class is used for the internal hashed column structure, so
that we can do fast lookups based on table names and column names.
|
| SchemaNameException |
This exception is thrown when there are any schema name issues, such as
duplicate column names, duplicate table names, ambiguous or invalid names,
and so forth.
|
| SchemaWriter |
This class contains a general purpose implementation for reading and
writing a table schema into a data page.
|
| SelectClause |
This class represents a single SELECT ... statement or clause.
|
| SelectCommand |
This command object represents a top-level SELECT command issued
against the database.
|
| SelectivityEstimator |
This utility class is used to estimate the selectivity of predicates that
appear on Select and Theta-Join plan-nodes.
|
| SelectNode |
PlanNode representing the WHERE clause in a SELECT
operation.
|
| SelectValue |
This class represents a single expression in a SELECT clause.
|
| SequentialTupleFile |
This interface extends the TupleFile interface, adding operations
that can be provided on files of tuples that are stored in a specific
sequential order. |
| ServerConfig |
|
| ServerProperties |
|
| SessionState |
This class holds all session state associated with a particular client
accessing the database.
|
| SetPropertyCommand |
Implements the "SET VARIABLE ..." command.
|
| SharedClientState |
This class represents
|
| SharedServer |
This class implements a "shared" database server that listens for incoming
connections on a socket, so that the database can have multiple concurrent
clients connected at the same time.
|
| SharedServerClient |
This class implements a client the can connect to the NanoDB
shared server and
send/receive commands and data. |
| ShowPropertiesCommand |
Implements the "SHOW VARIABLES" command.
|
| ShowSystemStatsCommand |
Implements the "SHOW [system] STATS" command.
|
| ShowTablesCommand |
Implements the "SHOW TABLES" command.
|
| ShowTableStatsCommand |
Implements the "SHOW TABLE t STATS" command.
|
| SimpleFilterNode |
This select plan node implements a simple filter of a subplan based on a
predicate.
|
| SimpleFunction |
Created by donnie on 12/5/13.
|
| SimplestPlanner |
This class generates execution plans for very simple SQL
SELECT * FROM tbl [WHERE P] queries.
|
| Sin |
Implementation of the SIN(x) SQL function, computes the sine of a
single argument.
|
| SortedGroupAggregateNode |
Implements grouping and aggregation by using sorting as a method to find
groups.
|
| SortMergeJoinNode |
This class implements the basic sort-merge join algorithm for use in join
evaluation.
|
| SortNode |
This plan node provides a simple in-memory sort operation for use in
ORDER BY clauses.
|
| SQLDataType |
An enumeration of the SQL data-types that are supported by NanoDB.
|
| Sqrt |
Computes the square root of a single argument.
|
| StatisticsUpdater |
This helper class provides basic functionality for updating column
statistics based on a selection predicate.
|
| StatsWriter |
This class encapsulates the operations of reading and writing
table-statistics to a data file.
|
| StdDev |
Created by donnie on 12/7/13.
|
| StdDevVarAggregate |
This aggregate function can be used to compute either the standard deviation
or the variance of a collection of values.
|
| StorageException |
This class and its subclasses represent general storage errors that can be
encountered when manipulating the various data files that comprise the
database.
|
| StorageManager |
The Storage Manager provides facilities for managing files of tuples,
including in-memory buffering of data pages and support for transactions.
|
| StringEnumValidator |
Validates a string property value against a collection of valid values; if
the value cannot be cast to a string or the value doesn't appear in the
collection of valid values, then an error will be reported.
|
| StringMatchOperator |
This class implements string matching operations.
|
| StringMatchOperator.Type |
This enumeration specifies the types of matching that can be performed.
|
| StringValueValidator |
Validates a string property value; if the value cannot be cast to a string
then an error will be reported.
|
| SubqueryOperator |
This class is the superclass of all expressions that can hold subqueries,
such as the IN operator, the EXISTS operator, and scalar
subqueries.
|
| SubquerySchemaComputer |
|
| Sum |
Created by donnie on 12/7/13.
|
| SumAvgAggregate |
This aggregate function can be used to compute both SUM and AVERAGE
functions.
|
| SumDistinct |
Created by donnie on 12/7/13.
|
| TableColumnDecl |
This class represents a single column declaration within a CREATE
TABLE command.
|
| TableConstraintType |
An enumeration specifying the constraint types allowed on tables.
|
| TableException |
This class represents errors that occur while manipulating tables.
|
| TableFunction |
This is the base-class for all table-returning functions.
|
| TableFunctionScanNode |
A select plan-node that produces the output of a specific table-returning
function, checking the optional predicate against each tuple.
|
| TableInfo |
This class represents a single table in the database, including the table's
name, and the tuple file that holds the table's data.
|
| TableManager |
This interface specifies the operations performed specifically on table
files.
|
| TableStats |
This class is a simple wrapper for table-file statistics.
|
| TableUtils |
Created by donnie on 7/16/17.
|
| Tan |
Implementation of the TAN(x) SQL function, computes the tangent of
a single argument.
|
| ThetaJoinNode |
PlanNode representing the FROM clause in a SELECT
operation.
|
| TransactionException |
This class represents errors that occur as part of transaction processing.
|
| TransactionManager |
The Transaction Manager is responsible for managing all aspects of proper
transaction processing within the database.
|
| TransactionState |
This class manages the transaction state associated with every client
session.
|
| TransactionStatePage |
This class wraps the transaction-state page to provide basic operations
necessary for reading and storing essential values.
|
| TransactionStateUpdater |
This implementation of the CommandEventListener interface manages
the transaction state enclosing each command executed by the database. |
| TruncationException |
This exception is a specific subtype of the type-cast exception that is
thrown when a type-conversion would cause a truncation of a value.
|
| Tuple |
This interface provides the operations that can be performed with a tuple.
|
| TupleBagNode |
This plan-node returns tuples from a collection specified on the node
before it is prepared.
|
| TupleComparator |
This class allows us to sort and compare tuples based on an order-by
specification.
|
| TupleFile |
This interface defines the most basic operations that all files storing
tuples must support.
|
| TupleFileException |
This class represents errors that occur while manipulating tuple files.
|
| TupleFileManager |
This interface defines the operations that can be performed on
TupleFiles, but that are at a higher level of implementation than
the tuple file itself. |
| TupleHasher |
|
| TupleLiteral |
A simple implementation of the Tuple interface for storing literal
tuple values. |
| TuplePrinter |
This implementation of the tuple-processor interface simply prints out
the schema and tuples produced by the SELECT statement.
|
| TupleProcessor |
This interface allows us to decouple the implementation of the query
evaluation loop from the operations performed on each tuple generated by the
evaluator.
|
| TupleSender |
This implementation of the tuple-processor interface sends the schema and
tuples produced by the SELECT statement over an
ObjectOutputStream.
|
| TupleUtils |
|
| TypeCastException |
This exception is thrown when the TypeConverter tries to cast
a value from one type to another incompatible type. |
| TypeConverter |
This class provides a whole bunch of helper functions for performing type
conversions on values produced by various expressions.
|
| UnderlineErrorListener |
|
| UpdateCommand |
This command object represents a top-level UPDATE command issued
against the database.
|
| UpdateCommand.TupleUpdater |
An implementation of the tuple processor interface used by the
UpdateCommand to update each tuple. |
| UpdateValue |
This class represents a single column-name/expression pair in an
UPDATE statement's SET clause.
|
| Variance |
Created by donnie on 12/7/13.
|
| VerifyCommand |
This Command class represents the VERIFY SQL command, which
verifies a table's representation (along with any indexes) to ensure that
all structural details are valid.
|
| WALFileException |
This exception class represents issues with write-ahead log files, when they
contain corrupt or invalid information in some way.
|
| WALManager |
This class manages the write-ahead logs of the database.
|
| WALRecordType |
This enumeration specifies the various types of records that can appear in
the write-ahead log, along with their numeric values that actually appear
within the write-ahead log.
|