Abstract Database Interface

[Jacob Carlborg]

On 2012-10-28 02:31, BLM768 wrote:
> I've recently been working with Ruby's ActiveRecord as part of my job,
> and I realized that D was powerful enough to make a similar abstraction
> layer. I've been playing with the idea for a little while, and I've put
> up some code at https://github.com/blm768/adbi. It isn't nearly as
> comprehensive as ActiveRecord, but it captures the basic idea of
> representing database structures as objects/structs.
>
> Using it is something like this:
>
> module main;
>
> import std.stdio;
>
> import adbi.model;
> import adbi.sqlite3.database;
>
> struct Test {
>      mixin Model!"test";
>
>      const(char)[] name;
>      double num;
>      mixin reference!("test2", "test2", Test2);
> }
>
> struct Test2 {
>      mixin Model!"test2";
>      int value;
> }
>
> int main(string[] args) {
>      auto db = new Sqlite3Database("test.db");
>      auto q = db.query("SELECT * FROM test;");
>
>      Test.updateSchema(db);
>      Test2.updateSchema(db);
>
>      auto range = ModelRange!Test(q);
>
>      foreach(value; range) {
>          writeln(value);
>      }
>
>      auto q2 = db.query("SELECT * FROM test, test2 WHERE test2_id =
> test2.id");
>
>      auto r2 = ModelRange!(Join!(Test, Test2))(q2);
>
>      foreach(j; r2) {
>          writeln(j);
>      }
>
>      return 0;
> }
>
> This code prints out every entry in the "test" table, then prints the
> results of a join on the "test" and "test2" tables. The calls to
> updateSchema() set up some static members of Test and Test2; after these
> calls, the library does not perform any operations with the column
> names, which should make retrieving a record noticeably faster than in a
> system like ActiveRecord. The downside is that these functions must be
> called every time the database schema changes in a way that affects
> column order, but that should happen very rarely, if ever, in a typical
> application.
>
> The code is far from complete, but it's an interesting toy and might
> actually be useful for simple applications once some of the issues are
> ironed out.

Looking at the API used in this example it would say that it's not very 
interesting and not very ActiveRecrod like. I think this looks more 
interesting and more like ActiveRecrod:

class Person : Model
{
}

void main ()
{
     auto p = new Person;
     p.name = "John Doe";
     p.save();

     p = Person.where!(x => x.name == "John Doe");
}

But when you start to use associative it won't be as nice looking as 
ActiveRecord due to the not so nice mixin syntax. What we need is AST 
macros and user defined attributes/annotations. With that, associations 
could potentially look like this:

class Foo : Model {}

class Person : Model
{
     @hasMany Foo;
}

-- 
/Jacob Carlborg