A laughably-minimalist, integer-only, read-only Relational Database Management System that makes the author question why they ever bothered to write it up!
19th August, 2020 Wednesday
There are 2 kinds of commands in this database.
Note: Not all operators have been implemented, some have been omitted for you to implement in later phases
Non-assginment statements do not create a new table (except load which just loads an existing table) in the process
The following haven't been implemented
Syntax:
LOAD <table_name>
Run: LOAD A
LOAD A
Syntax
LIST TABLES
This command lists all tables that have been loaded or created using assignment statements
Run: LIST TABLES Run: LOAD B, LIST TABLES
LOAD B
PRINT <table_name>
Run: PRINT B
PRINT B
RENAME <toColumnName> TO <fromColumnName> FROM <table_name>
Run: RENAME b TO c FROM B
RENAME b TO c FROM B
EXPORT <table_name>
Run: EXPORT B
EXPORT B
CLEAR <table_name>
Run: CLEAR B
CLEAR B
QUIT
Run: QUIT
INDEX ON <columnName> FROM <table_name> USING <indexing_strategy>
Where <indexing_strategy> could be
BTREE
HASH
NOTHING
All assignment statements lead to the creation of a new table.
Every statement is of the form <new_table_name> <- <assignment_statement>
<new_table_name> <- <assignment_statement>
Naturally in all cases, <new_table_name> shouldn't already exist in the system
<new_table_name> <- CROSS <table_name1> <table_name2>
Run: cross_AA <- CROSS A A
cross_AA <- CROSS A A
A(A, B) x A(A, B) -> cross_AA(A1_A, A1_B, A2_A, A2_B)
<new_table_name> <- SELECT <condition> FROM <table_name>
Where <condition> is of either form
<first_column_name> <bin_op> <second_column_name> <first_column_name> <bin_op> <int_literal>
Where <bin_op> can be any operator among {>, <, >=, <=, =>, =<, ==, !=}
Run: R <- SELECT a >= 1 FROM A S <- SELECT a > b FROM A
R <- SELECT a >= 1 FROM A
S <- SELECT a > b FROM A
<new_table_name> <- PROJECT <column1>(,<columnN>)* FROM <table_name>
Run: C <- PROJECT c FROM A
C <- PROJECT c FROM A
<new_table_name> <- DISTINCT <table_name>
Exmample: D <- DISTINCT A
D <- DISTINCT A
<new_relation_name> <- JOIN <table1>, <table2> ON <column1> <bin_op> <column2>
Where <bin_op> means the same as it does in the SELECT operator
Example: J <- JOIN A, B ON a == a
J <- JOIN A, B ON a == a
<new_table_name> <- SORT <table_name> BY <column_name> IN <sorting_order>
Where <sorting_order> can be ASC or DESC
ASC
DESC
Example: S <- SORT A BY b IN ASC
S <- SORT A BY b IN ASC
SOURCE <query_name>
Buffer Manager
Cursors
Tables
Executors
Run: LOAD A with debugger
see: load.cpp
see: syntacticParser.h syntacticParser.cpp
see: semanticParser.h semanticParser.cpp
Every command(COMMAND) has a file in the executors directory, within that directory you'll find 3 functions
syntacticParseCOMMAND semanticParseCOMMAND executeCOMMAND
Load splits and stores the table into blocks. For this we utilise the Buffer Manager
Buffer Manager follows a FIFO paradigm. Essentially a queue
A cursor is an object that acts like a pointer in a table. To read from a table, you need to declare a cursor.
Run: R <- SELECT a == 1 FROM A with debugger
R <- SELECT a == 1 FROM A
Every function call is logged in file names "log"
Note: may include duplicate elimination