[std.database]

[Jacob Carlborg]

On 2011-10-11 05:08, Johann MacDonagh wrote:
> On 10/8/2011 2:43 AM, Steve Teale wrote:
>> I use this title at Andrei's suggestion, and repeat his idea that it
>> be used
>> as a prefix for discussions as we navigate toward a design. Unless
>> there is
>> resistance to the idea, I will on the job of implementing whatever we
>> decide
>> is appropriate. I am retired, and have the time to do it.
>>
>> It seems that every man, and possibly his dog, has a private
>> implementation
>> for at least a favorite DB, so we should have plenty of material to
>> build on.
>>
>> At this point I would like to get responses from those who feel they are
>> likely to contribute to the design through to completion.
>>
>> I'd also like to get a feel for the magnitude of the task, so I'd like
>> to ask
>> what database systems you think should be supported.
>>
>> I have started a github account, and will put my mysqld stuff there
>> shortly,
>> then you can kick me out if you don't like what you see.
>>
>> Steve
>
> I've written up a prototype for a "LINQ" style database querying
> mechanism in D (read about "LINQ to SQL" if you've never heard of it).
> Legally speaking, it has very little to do with LINQ, but the concept is
> similar.
>
> Basically, it allows you to write code like this:
>
> auto x = new SqliteConnection("mydata.db");
>
> foreach(y; x.MyTable.where("someField > 10"))
> {
> // y is a wrapper around Variant[string] with some opDispatch magic
> writeln(to!string(y.MyField));
> writeln(to!int(y.SomeOtherField));
> }
>
> Of course, "MyTable" is handled via opDispatch. The SqliteConnection
> doesn't care what tables are available in "mydata.db". You can also do
> much more. Such as:
>
> x.MyTable.startAt(20).limit(10).where("blah").select("somefield",
> "sometingElse");
>
> In addition, you should be able to do something like this (don't think
> I've implemented this yet):
>
> x.MyTable.select!MyStruct();
>
> Doing that would return a range of MyStruct structs, rather than the
> wrapper around Variant[string] like above. This would allow you to do:
>
> auto x = new SqliteConnection("mydata.db");
>
> foreach(y; x.MyTable.where("someField > 10").select!MyStruct())
> {
> // y is a wrapper around Variant[string] with some opDispatch magic
> writeln(y.MyField); // No more needing the to! template
> writeln(y.SomeOtherField);
> }
>
> Of course, this would allow you to find typos in field names at compile
> time (provided your struct is kept in sync with the database), and means
> you don't have to go through the Variant[string] for all your database
> accesses.
>
> To implement this, a database "driver" would have to have a shared
> opDispatch implementation (perhaps done with a mixin or maybe with an
> abstract class), and it would have to be able to translate the "query"
> into a SQL query that works with their underlying database system.
>
> I have a working prototype somewhere that works with Sqlite, and it
> seems to work very nicely. Clearly a system like this shows off what D
> can do out of the box (opDispatch), and makes writing scripts very easy.
>
> Let me know if this is something you think should be part of
> std.database (or whatever we end up calling it).

I think that the use of opDispatch and selecting with a struct should be 
available at the higher level interfaces and not in the low level interface.

-- 
/Jacob Carlborg