[boost] Re: Serialization to relational table

From: Arkadiy Vertleyb (vertleyb_at_[hidden])
Date: 2002-11-19 17:25:20

Bohdan,

If I understand correctly you have some way to split an object into fields.
After you do it, what are your fields, strings?  If so, this is good enough
for putting an object in the grid, but we actually try to achieve different
goals.  We are implementing relational algebra -- joins, projections, etc.
on relational tables that look like STL containers, and can have columns of
arbitrary (built-in or user-defined) types.  Templates allow us to achieve
this in a typesafe manner.

You are right, we can't dynamically define table schema, this is the price
for type safety.

Having said that, I am not sure that RTL is a suitable tool for XML
serialization or any serialization at all (I maybe wrong, though).  In fact
RTL itself needs to collaborate with a serialization library.  We think
persistence and relational algebra are ortogonal things that are often put
together because of RDBMS.  Since RTL was mentioned in this context, I
thought I needed to provide certain clarifications.

Arkadiy

"Bohdan" <warever_at_[hidden]> wrote in message
news:ardj19$l3r$1_at_main.gmane.org...
> > Sure it is, but I can't claim I understand what you mean in this
particular
> > case...
> >
> > Arkadiy
>
> Sorry, i was unclear.
> I should look at RTL closer to find similarities and differences to my
idea.
> But first glance reveals difference between two:
>
> RTL : all classes are templates and one can adapt them to his needs.
>       library has a lot of compile time things.
>
>       pros:
>             speed - a lot of compile time optimization.
>       cons:
>             size - each object has at least one table template
instantination.
>             flexibility - one can not define table schema in runtime ( i'm
not
> sure ).
>
>
> my  : all classes are completely runtime.
>       table class is similar to std::ostream.
>       The only difference means that table contents
>       is structured.
>       it means that you can do following:
>
>            class A;
>            in_memory_builder b;
>            table& t = b.create_table();
>            A::define_table( t ); //user func
>            A x,y,z;
>            x.add_record( t );   //analogy to std::ostream is "t << x;"
>            y.add_record( t );
>            z.add_record( t );
>            gui_grid_control.show( t );
>            to_xml( t, "out.xml" );
>
>        no templates!
>        pros:
>             fexibility - runtime table definition
>             size - fixed set of classes
>        cons:
>             speed - most probably a lot of virtual functions.
>
>
> Note! My knowledges about RTL are far from good. Just first glance.
> I failed to compile rtl with my compiler. Will try once again.
>
> regards,
> bohdan
>
>
>
>
> _______________________________________________
> Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost
>