On Sunday, 28 October 2012 at 00:31:49 UTC, 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.
I am working on similar project, named SQLd[1]. If you are
interested, we can join forces and work togheder :)
IRC Nick: Robik
[1]: http://github.com/robik/SQLd