Current status of lambda-DB

Minor changes. Things done:

Added TPC-D benchmark queries (directory examples/tpcd/) written by Shruti Sharma.
Converted joins with key or OID equalities on class extents into object dereferences. For example, select e, c from e in Instructors, c in Courses where c.taught_by.ssn=e.ssn is converted into select c.taught_by, c from c in Courses. This is a fix for those who like to program using joins (SQL style) rather than in OQL style.

Minor changes. Things done:

Minor changes. Things done:

Fixed the %e1.A := e2; assignment to update the indexes that depend on A.
Extended OQL functions to support ODL methods using the syntax %define class::method (...) as query;.
Added the %print query; command to print query results of compiled queries.
Added method overloading across classes (but not within a class).

Minor changes. Things done:

Things done:

Added recursive functions to capture transitive closure. Tested on XML data.
Converted the code to ANSI C++ and ported it to RHL 7.0.
By default, objects are now transient when constructed. To make an object persistent (ie, stored in a class extent) you must put the keyword "persistent" before the object construction. "Persistent by reachability" is not supported any more (reason: if an objects has been created as transient, the indexes will not be updated).

Things done:

Now the optimizer can run in different modes: with or without query unnesting, with or without materialization of path expressions, and with or without mapping unnests into joins. Voodoo now allows you to choose modes.
Added support for enum and union types in OQL. Added a case statement to the OQL language to manipulate union types. Modified voodoo to handle union values. Created another example directory (XML) that has a schema with two union types.
Made block-nested-loop work as outer-join when needed.
Run benchmark queries (available at lambda-DB/example/benchmarks.oql) and tuned the evaluation engine.
Merged voodoo.tcl with the oql_server into one program (called voodoo).

Things done:

Now lambda-DB uses a new version of SHORE that works with new Red-Hat Linux without using the old libc libraries (thanks to Jim Smith jim.smith@ncl.ac.uk).
Modified the SHORE source code to fix the file permission of some SDL files. Now lambda-DB can be used for class projects by many students.

Fixed minor bugs:

Fixed the interpreter to handle bag-of-bag queries, such as select (select c.name from c in e.teaches) from e in Instructors.
Added object deletion from a class extent.

Things done:

Replaced the sorting algorithm. Now sorting uses quicksort to sort a fixed number of tuples in memory and then it dumps them into runfiles. The resulting runfiles are then merged in one step using a priority queue implemented as a heap. If all tuples can fit in memory, no runfiles are created.
Implemented block nested loop and changed the optimizer/code-generator to incorporate it.
Now order-by clause can sort in descending order when specified (using desc).
Fixed the object printer of the interpreter so it can print nested collections and objects to any (prespecified) nesting level.
Fixed the problem of materializing a stream to a value in the header of a query needed in queries such as select set(teaches) from Instructors. To do this, I had to use a stack of stream environments instead of just a fixed number of streams.
Added more accumulator choices in voodoo and improved the interface.

Things to do:

Future plans:

Next version will probably be an alpha release (before the sigmod 2000 demo, I hope).

Things done:

Ported to new i486 Red Hat Linux (tested on RHL 6.0).
Completed the OQL interpreter. Now the code generator produces functional-style code (higher-order functions and lambda abstractions) and this code is then translated into C++ using defunctionalization. The code can also be evaluated by the interpreter with minimal overhead.
Connected the VOODOO visual query formulator with the interpreter.
Changed the DB files access modes. Now the system is multi-user but with no security.
Improved the manual.
Fixed various bugs (thanks to Akhtar Muhammad for reporting some of them).

Things to do:

Performance considerations discussed in the previous release will (hopefully) be addressed in the next major release.
One UTA student is working on a GUI data browser.
Another UTA student is making the catalog ODMG-compliant.

Things done:

The optimization of group-by queries was considerably improved. This required to make the nest operator more like a group-by: now it can group-by any list of path expressions. This means that nest now requires sorting when grouping-by non-key attributes. Future extension will use hashing to form groups instead of sorting.
Now the optimizer eliminates duplicate nestings. For example, in the query:
```
      select count(e.teaches)
        from e in Employees
       where count(e.teaches) > 0
```
the count(e.teaches) (an unnest followed by a nest) is translated once.
Fixed the bug of translating queries with subqueries in the order-by clause.
Fixed the bug of predicate promotion (which was premature in some cases).
Announced the release to DBWORLD.

Things to do:

Currently sorting is done with B+-trees! This contributes to performance degradation.
Need to implement block-nested-loop and hybrid-hash join.
Need to have two kinds of keys: strings and integers (now everything is mapped to strings).
Need special algorithms for pointer joins.
Need an OQL interpreter (hard to do).

Bugs:

It puts the predicate x.name="Smith" in a wrong place:

exists x in Instructors:
for all c in x.teaches: x.name = "Smith" and c.name="DB"

Can't have a nested query in an order-by (this is easy to fix):

select d.name
from d in Departments
order by count(select * from e in d.instructors
               where e.rank = "Full Professor")

Last modified: 11/13/01 by Leonidas Fegaras