Curiosity killed the cat.

• Prestazioni?
• Scalabilità orizzontale?
• Replica?
• Variazioni dello schema?
• Indicizzazione e ricerca?
• Constraint sui dati?
• Gestione della concorrenza?
• Transazioni?
• Amministrazione?

• commerciale con integrazione nell’ambiente di sviluppo;
• free e stand alone, completamente scritto in java. Una chiavica… le cose che non vanno al primo colpo a me personalmente fanno roteare i ma*oni al volo :-)

• Db4objects.Db4o.dll;
• Db4objects.Db4o.Linq.dll (e qui slurp…);

var person = new Person();
person.FirstName = "Mauro";
person.LastName = "Servienti";
person.BornDate = new DateTime( 1973, 1, 10 );

Console.WriteLine( person );

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    db.Store( person );

    var query = db.Cast<Person>()
        .Where( p => p.FirstName.StartsWith( "M" ) );

    foreach( var p in query )
    {
        Console.WriteLine( p );
    }
}

• Single User, quella dell’esempio, che non è realmente single user ma va poco oltre;
• Client-Server: simile al tradizionale accesso che siamo abituati a fare ad un rdbms in rete;

• Il più evidente: pieno supporto per Linq e per gli Expression tree: quell’extension method Cast (pessima scelta di naming) infatti non è il Cast di IEnumerable ma bensì l’entry point per dire al motore di costruzione delle query quale è la “tabella master” su cui volete operare, nei miei esempi mi sono già fatto un extension method decisamente più parlante:

static class ObjectContainerExtensions
{
    public static IDb4oLinqQuery From( this IObjectContainer db )
    {
        return db.Cast();
    }
}

Possiamo quindi fare un paragone molto spannometrico e dire che l’istanza di IObjectContainer ritornata dalla OpenFile() è paragonabile al concetto di DataContext di Linq2Sql/EF ed in effetti ogni IObjectContainer rappresenta in tutto e per tutto una Unit of Work con, secondo concetto importante:

• Identity Map: un IObjectContainer implementa quindi i pattern UnitOfWork e Identity Map;

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    IObjectSet result = db.QueryByExample( new Person() { FirstName = "Mauro" } );
    foreach( Object obj in result )
    {
        Console.WriteLine( obj );
    }
}

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    var result = db.Query<Person>( p => p.FirstName == "Mauro" );
    foreach( Object obj in result )
    {
        Console.WriteLine( obj );
    }
}

• Retrocompatibilità;
• Costruzione dinamica delle query: problema direi superato con gli ExpressionTree, per i linguaggi che li supportano;

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    var query = db.Query();
    query.Constrain( typeof( Person ) );
    query.Descend( "k__BackingField" )
        .Constrain( "Mauro" );

    var result = query.Execute();

    foreach( Object obj in result )
    {
        Console.WriteLine( obj );
    }
}

sealed class Person
{
    public String FirstName
    {
        get;
        set;
    }

    public String LastName
    {
        get;
        set;
    }

    public DateTime BornDate
    {
        get;
        set;
    }

    public Int32 Age
    {
        get { return ( ( Int32 )( DateTime.Now.Date - this.BornDate ).TotalDays / 365 ); }
    }

    public override string ToString()
    {
        return String.Format( "{0} {1}, {2}", this.FirstName, this.LastName, this.Age );
    }
}

• è “sealed”;
• Non ha nessun membro virtual, e non potrebbe è sealed ;-);
• Non è pubblica;
• E’ effettivamente POCO, non c’è proprio nulla che ci faccia pensare che abbia qualcosa a che fare con un db;

var person = new Person();
person.FirstName = "Mauro";
person.LastName = "Servienti";
person.BornDate = new DateTime( 1973, 1, 10 );

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    db.Store( person );
    db.Store( person );
    
    Console.WriteLine( "Double Store, Count: {0}", db.From<Person>().Count() );
}

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    db.Store( person );
    Console.WriteLine( "Single Store, Count: {0}", db.From<Person>().Count() );
}

using( var db = Db4oFactory.OpenFile( @"c:\temp\db4o_Sample.db4o" ) )
{
    Console.WriteLine( "Count: {0}", db.From<Person>().Count() );

    var query = db.From<Person>()
        .Where( p => p.FirstName.StartsWith( "M" ) );

    foreach( var p in query )
    {
        Console.WriteLine( p );
    }
}

• Creiamo una singola istanza della classe Person;
• Apriamo un “data context” e salviamo la stessa istanza 2 volte: questo porta, giustamente ad una singola “insert”, la doppia Store viene semplicemente ignorata in questo esempio perchè l’istanza di Person è “known” ergo il data context si rendo conto che la doppia store è un “non sense”
• Chiudiamo il data context e ne apriamo un altro rifacciamo la store e “boom” a questo punto abbiamo 2 “record” nel nostro database… siamo in modalità disconnessa a questo punto e giustamente l’engine non ha la più pallida idea che Person sia la stessa di prima; cosa possiamo fare?

long id;

using( var db = Db4oFactory.OpenFile( config, @"c:\temp\db4o_Sample.db4o" ) )
{
    db.Store( person );
    db.Store( person );

    Console.WriteLine( "Double Store, Count: {0}", db.From<Person>().Count() );

    id = db.Ext().GetID( person );

    db.Close();
}

using( var db = Db4oFactory.OpenFile( config, @"c:\temp\db4o_Sample.db4o" ) )
{
    db.Ext().Bind( person, id );
    db.Store( person );

    Console.WriteLine( "Single Store, Count: {0}", db.From<Person>().Count() );

    db.Close();
}

• Servizio WCF che maschera lo storage;
• Applicazione client;
• Il client recupera un grafo complesso di oggetti;
• Vengono modificati solo alcuni oggetti;
• Siccome il client è intelligente rimanda al servizio solo la parte modificata;
• Il servizio chiama Bind() e… solo una parte viene rimpiazzata in memoria con la “fastidiosa” conseguenza che quando chiamate Store() all’engine arriva un grafo parziale, con un id esistente e il buon db4o, giustamente, cancella dal db quello che non gli arriva… ooops…

var query = db.From<Person>()
    .Where( p => p.FirstName.StartsWith( "M" ) && p.Addresses.Count > 2 );