Add wrapper support for composite values

NULL semantics for composite values is not yet supported.

4 files changed, 60 insertions, 14 deletions

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<statement_oids> 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 <statement_oids> st;
                 st->traverse_composite (m, *vtc, "value", "value");