If you choose this option then you will implement a small columnar query execution engine that reads data from CSV files.

In the first assignment, you will build support for reading a table from a CSV file into memory as columar data in horizontal chunks. You need to design the data structures for holding a table chunk which stores data of all rows in a horizontal chunk of the input table of a fixed size, say 4096 rows. The table chunk just holds metadata and references to column chunks which, for fixed size data types like 4-byte integers, should just be an array of elements of this type. For variable length data like strings, you can use the two array (offset + an array concatenating all strings) as a storage format or implement "German" strings where small strings are stored inline and larger ones in a separate array. For convenience, you should also implement a function that can print chunks in a human-readable format.

In the second assignment, we will implement or first two query engine operators and supporting vectorized versions of scalar operations.

• Projection: A basic projection is trivial to implement in a columnar database. Just remove references to column chunks that are projected out. For scalar expressions, e.g., A+B we need to implement vectorized versions of these operators that take column chunks as inputs and return column chunks.
• Selection: selection filters rows based on a condition. For our columnar engine, we want to evaluate the individual operations in a selection condition on full table chunks. For that we should implement support for basic primitives like logical operators and comparisons on column chunks. Comparison operators should take two column chunks or constants and return a bitvector encoding for each row whether the condition evaluates to true or not. Logical operators can then be implemented as bitwise operations: (and) is bitwise and, (or) is bitwise or, (not) is bitwise not. Once we have evaluated a full selection condition we have to use the resulting bitvector to filter the actual columns by removing all elements at positions where the bitvector is 0.

In this assignment, you will implement a hash join operators (it is ok to only support the version that assumes that the hash table fits into memory). Recall that hash joins work for equality only (other conditions can be applied in a postfilter). You build a hash table on the smaller of the two inputs where the key is the join attributes, e.g., for this query:

1
2

SELECT *
FROM R JOIN S ON (R.A = S.B);

assuming that R is larger, we would build a hash table on S with key B. The values associated with a key c are all the rows from the table (S in our example) that have a join key equals to c.

Then you have to scan through the other input relation (R in our example) and for each row probe the hash table to find matching rows from the other table (S in our example) and output them.

In this last assignment, you will implement support for group-by aggregation and zonemap indexes.

I will provide a workload of queries expressible with the operators you have implemented and the fastest group wins.