Helper for implementing DbFileIterators. Handles hasNext()/next() logic.

Helper for implementing DbIterators. It handles <code>close</code>, <code>next</code> and <code>hasNext</code>. Subclasses only need to implement <cod

The Aggregator operator that computes an aggregate (e.g., sum, avg, max, min). Note that we only support aggregates over a single column, grouped by

The common interface for any class that can compute an aggregate over a list of Tuples.

BufferPool manages the reading and writing of pages into memory from disk. Access methods call into it to retrieve pages, and it fetches pages from th

The Catalog keeps track of all available tables in the database and their associated schemas. For now, this is a stub catalog that must be populated w

Class returned by {@link JoinOptimizer#computeCostAndCardOfSubplan} specifying the cost and cardinality of the optimal plan represented by plan.

JUnit fixture that creates a heap file and cleans it up afterward.

Database is a class that initializes several static variables used by the database system (the catalog, the buffer pool, and the log files, in

Generic database exception class

The interface for database files on disk. Each table is represented by a single DbFile. DbFiles can fetch pages and iterate through tuples. Each file

DbFileIterator is the iterator interface that all SimpleDB Dbfile should implement.

DbIterator is the iterator interface that all SimpleDB operators should implement. If the iterator is not open, none of the methods should work, and s

Debug is a utility class that wraps println statements and allows more or less command line output to be turned on. <p> Change the value of the DEBUG_

The delete operator. Delete reads tuples from its child operator and removes them from the table they belong to.

Creates a heap file with 1024 500 tuples with two integer fields each. Clears the buffer pool, and performs a sequential scan through all of the page

Interface for values of fields in tuples in SimpleDB.

Filter is an operator that implements a relational select.

HeapFile is an implementation of a DbFile that stores a collection of tuples in no particular order. Tuples are stored on pages, each of which is a f

HeapFileEncoder reads a comma delimited text file or accepts an array of tuples and converts it to pages of binary data in the appropriate format for

HeapPage stores pages of HeapFiles and implements the Page interface that is used by BufferPool. @see HeapFile @see BufferPool

Unique identifier for HeapPage objects.

Inserts tuples read from the child operator into the tableid specified in the constructor

We reserve more heavy-duty insertion testing for HeapFile and HeapPage. This suite is superficial.

Counts the number of readPage operations.

Knows how to compute some aggregate over a set of IntFields.

Instance of Field that stores a single integer.

A class to represent a fixed-width histogram over a single integer-based field.

The Join operator implements the relational join operation.

The JoinOptimizer class is responsible for ordering a series of joins optimally, and for selecting the best instantiation of a join for a given

JoinPredicate compares fields of two tuples using a predicate. JoinPredicate is most likely used by the Join operator.

Helper class that attempts to acquire a lock on a given page in a new thread. @return a handle to the Thread that will attempt lock acquisition after

<p> The format of the log file is as follows: <ul> <li> The first long integer of the file represents the offset of the last written checkpoint, or

A LogicalFilterNode represents the parameters of a filter in the WHERE clause of a query. <p> Filter is of the form t.f p c <p> Where

A LogicalJoinNode represens the state needed of a join of two tables in a LogicalQueryPlan

LogicalPlan represents a logical query plan that has been through the parser and is ready to be processed by the optimizer. <p> A LogicalPlan consits

A LogicalScanNode represents table in the FROM list in a LogicalQueryPlan

A LogicalSelectListNode represents a clause in the select list in a LogicalQueryPlan

A LogicalSubplanJoinNode represens the state needed of a join of a table to a subplan in a LogicalQueryPlan -- inherits state from {@link LogicalJoinN

Mock SeqScan class for unit testing.

Constants used for return codes in Field.compare

OrderBy is an operator that implements a relational ORDER BY.

Page is the interface used to represent pages that are resident in the BufferPool. Typically, DbFiles will read and write pages from disk. <p> Pages

PageId is an interface to a specific page of a specific table.

Class representing requested permissions to a relation/file. Private constructor with two static objects READ_ONLY and READ_WRITE that represent the t

A PlanCache is a helper class that can be used to store the best way to order a given set of joins

Predicate compares tuples to a specified Field value.

Project is an operator that implements a relational projection.

Query is a wrapper class to manage the execution of queries. It takes a query plan in the form of a high level DbIterator (built by initiating

A RecordId is a reference to a specific tuple on a specific page of a specific table.

Dumps the contents of a table. args[1] is the number of columns. E.g., if it's 5, then ScanTest will end up dumping the contents of f4.0.txt.

SeqScan is an implementation of a sequential scan access method that reads each tuple of a table in no particular order (e.g., as they are laid out on

Base class for all SimpleDb test classes. @author nizam

Stub DbFile class for unit testing.

Knows how to compute some aggregate over a set of StringFields.

Instance of Field that stores a single String of a fixed length.

A class to represent a fixed-width histogram over a single String-based field.

TableStats represents statistics (e.g., histograms) about base tables in a query

Transaction encapsulates information about the state of a transaction and manages transaction commit / abort.

Exception that is thrown when a transaction has aborted.