From 64d0ceffaaf5f57a3d24a5210bf0ad2a8474a618 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Fri, 26 Aug 2011 12:13:18 +0200 Subject: Add wrapper support for composite values NULL semantics for composite values is not yet supported. --- odb/relational/pgsql/common.cxx | 15 ++++++++++----- odb/relational/pgsql/common.hxx | 17 +++++++++++++++-- odb/relational/pgsql/schema.cxx | 2 +- odb/relational/pgsql/source.cxx | 40 ++++++++++++++++++++++++++++++++++------ 4 files changed, 60 insertions(+), 14 deletions(-) (limited to 'odb/relational/pgsql') diff --git a/odb/relational/pgsql/common.cxx b/odb/relational/pgsql/common.cxx index c5e3c9f..d6ef9c3 100644 --- a/odb/relational/pgsql/common.cxx +++ b/odb/relational/pgsql/common.cxx @@ -35,9 +35,13 @@ namespace relational semantics::type& t (type_override_ != 0 ? *type_override_ : m.type ()); - if (comp_value (t)) + if (semantics::class_* comp = comp_value_wrapper (t)) { - member_info mi (m, t, var, fq_type_override_); + // If t is a wrapper, pass the wrapped type. Also pass the + // original, wrapper type. + // + member_info mi ( + m, *comp, (wrapper (t) ? &t : 0), var, fq_type_override_); if (pre (mi)) { traverse_composite (mi); @@ -46,7 +50,7 @@ namespace relational } else if (container (t)) { - member_info mi (m, t, var, fq_type_override_); + member_info mi (m, t, 0, var, fq_type_override_); if (pre (mi)) { traverse_container (mi); @@ -59,7 +63,8 @@ namespace relational if (semantics::class_* c = object_pointer (t)) { - member_info mi (m, id_member (*c)->type (), var, fq_type_override_); + member_info mi ( + m, id_member (*c)->type (), 0, var, fq_type_override_); mi.st = &st; if (pre (mi)) { @@ -69,7 +74,7 @@ namespace relational } else { - member_info mi (m, t, var, fq_type_override_); + member_info mi (m, t, 0, var, fq_type_override_); mi.st = &st; if (pre (mi)) { diff --git a/odb/relational/pgsql/common.hxx b/odb/relational/pgsql/common.hxx index 52fcd2d..f41ca8c 100644 --- a/odb/relational/pgsql/common.hxx +++ b/odb/relational/pgsql/common.hxx @@ -30,14 +30,21 @@ namespace relational { semantics::data_member& m; // Member. semantics::type& t; // Member C++ type (m.type () may != t). + semantics::type* wrapper; // Wrapper type if member is a wrapper. + // In this case t is the wrapped type. sql_type const* st; // Member SQL type (only simple values). string& var; // Member variable name with trailing '_'. // C++ type fq-name. // string - fq_type () const + fq_type (bool unwrap = true) const { + // At the moment a wrapped type can only be a composite value. + // + if (wrapper != 0 && unwrap) + return t.fq_name (); + // Use the original type from 'm' instead of 't' since the hint // may be invalid for a different type. Plus, if a type is // overriden, then the fq_type must be as well. @@ -51,9 +58,15 @@ namespace relational member_info (semantics::data_member& m_, semantics::type& t_, + semantics::type* wrapper_, string& var_, string const& fq_type) - : m (m_), t (t_), st (0), var (var_), fq_type_ (fq_type) + : m (m_), + t (t_), + wrapper (wrapper_), + st (0), + var (var_), + fq_type_ (fq_type) { } }; diff --git a/odb/relational/pgsql/schema.cxx b/odb/relational/pgsql/schema.cxx index 191d522..5bfbc71 100644 --- a/odb/relational/pgsql/schema.cxx +++ b/odb/relational/pgsql/schema.cxx @@ -214,7 +214,7 @@ namespace relational // value // - if (semantics::class_* cvt = comp_value (vt)) + if (semantics::class_* cvt = comp_value_wrapper (vt)) { object_columns_references ocr (e_, os_, name); ocr.traverse_composite (m, *cvt, "value", "value"); diff --git a/odb/relational/pgsql/source.cxx b/odb/relational/pgsql/source.cxx index bfc26ba..1bba68a 100644 --- a/odb/relational/pgsql/source.cxx +++ b/odb/relational/pgsql/source.cxx @@ -420,6 +420,18 @@ namespace relational << "//" << endl; } + // If this is a wrapped composite value, then we need to + // "unwrap" it. For simple values this is taken care of + // by the value_traits specializations. + // + if (mi.wrapper != 0 && comp_value (mi.t)) + { + // Here we need the wrapper type, not the wrapped type. + // + member = "wrapper_traits< " + mi.fq_type (false) + " >::" + + "get_ref (" + member + ")"; + } + if (comp_value (mi.t)) traits = "composite_value_traits< " + mi.fq_type () + " >"; else @@ -515,8 +527,9 @@ namespace relational virtual void traverse_composite (member_info& mi) { - os << "if (" << traits << "::init (i." << mi.var << "value, " << - member << "))" + os << "if (" << traits << "::init (" << endl + << "i." << mi.var << "value," << endl + << member << "))" << "{" << "grew = true;" << "}"; @@ -650,6 +663,18 @@ namespace relational << "//" << endl; } + // If this is a wrapped composite value, then we need to + // "unwrap" it. For simple values this is taken care of + // by the value_traits specializations. + // + if (mi.wrapper != 0 && comp_value (mi.t)) + { + // Here we need the wrapper type, not the wrapped type. + // + member = "wrapper_traits< " + mi.fq_type (false) + " >::" + + "set_ref (" + member + ")"; + } + if (comp_value (mi.t)) traits = "composite_value_traits< " + mi.fq_type () + " >"; else @@ -734,8 +759,10 @@ namespace relational virtual void traverse_composite (member_info& mi) { - os << traits << "::init (" << member << ", i." << - mi.var << "value, db);" + os << traits << "::init (" << endl + << member << "," << endl + << "i." << mi.var << "value," << endl + << "db);" << endl; } @@ -1065,7 +1092,8 @@ namespace relational case ck_map: case ck_multimap: { - if (semantics::class_* ktc = comp_value (container_kt (mt))) + if (semantics::class_* ktc = + comp_value_wrapper (container_kt (mt))) { instance st; st->traverse_composite (m, *ktc, "key", "key"); @@ -1083,7 +1111,7 @@ namespace relational } } - if (semantics::class_* vtc = comp_value (vt)) + if (semantics::class_* vtc = comp_value_wrapper (vt)) { instance st; st->traverse_composite (m, *vtc, "value", "value"); -- cgit v1.1