Rel 30e6e98

Manuals

A few things are TODO.

These manuals are available:

• The database tutorial is a short tutorial. It assumes you have SQLite3 installed, that you want to make your own database and that you want to fully model it in OCaml.
• The query tutorial is a short tutorial. It assumes you need to query an existing SQLite3 database.
• The schema quick start and how-to discusses how to manage your database schema when using Rel.
• The query quick start and how-to discusses how to query your data ith Rel's embedded query language.
• The SQLite3 quick start and how-to explain how to deal with SQLite3 databases.
• The SQL statement typing manual explains the low-level mecanism to type and execute SQL statements.

The rel library

• Rel Relational databases.
• Rel_sql SQL helpers.
• Rel_query Embedded query language.
• Rel_list Query OCaml lists of rows.
• Rel_kit Schema definition helpers.

Database management systems

Each of these modules live in its own rel.* library.

• Rel_sqlite3 SQLite3 support.

Convenience libraries

Each of these modules live in its own rel.* library.

• Rel_kit Schema definition helpers.
• Rel_cli Cmdliner fragments.
• Rel_pool Pools of reusable resources.

TODO

• SQLite seems quite unique in not specifying a size for text. We likely need to add an int to Rel.Type.Text at some point.

• When we try to prepare a statement with a comment, our error path through the DB handle gets a misleading out of memory error. If we consult the error message of the code it's SQL_MISUSE. (?) a bit unclear what the correct workflow is here.

• A simple short, tutorial.

• Rel should maybe depend on Rel_sql, or possibly have a pre-Rel_sql with the expression language, since we will hit recursive dependencies. One issue is that we would like to be able to define an expression for the default of columns. This should be parametric on the dialect and/or be a structured SQL expression.

• Having Rel_sql.dialect at the level of statements creation is a bit annoying. Maybe go back to the idea of having an AST in Rel_sql.Stmt.src. The backends then directly act on this. The only thing we need is something that is fast to test for equality for caches of prepared statements.

• Rel.Col need a collation parameter. Also the `Expr Rel.Col.default case is unsatisfying it should be either an SQL expression AST or at least be a function of the dialect (which gets us into recursive trouble). Also for indexes this is not as expressive as it could be.

• Sort-out the naming stuff. For constraints and indices (the Rel.Table.Index.get_name stuff is not that great, should we simply have "" as a default and rename when we add to a table ?)

• Table updates or inserts we can likely avoid going through listts of Rel.Col.value value but that's not what we have in the API at the moment.

• Rel_sqlite3 changes. Be smarter on tables changes that involve only index/add drops.