3 files changed, 56 insertions, 11 deletions

diff --git a/odb/relational/sqlite/common.cxx b/odb/relational/sqlite/common.cxx
index 010e267..d9f79b0 100644
--- a/odb/relational/sqlite/common.cxx
+++ b/odb/relational/sqlite/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/sqlite/common.hxx b/odb/relational/sqlite/common.hxx
index 0c9aae0..e3f81a5 100644
--- a/odb/relational/sqlite/common.hxx
+++ b/odb/relational/sqlite/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/sqlite/source.cxx b/odb/relational/sqlite/source.cxx
index 6a99fc8..a482184 100644
--- a/odb/relational/sqlite/source.cxx
+++ b/odb/relational/sqlite/source.cxx
@@ -239,6 +239,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
@@ -333,8 +345,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;"
              << "}";
@@ -413,6 +426,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
@@ -497,8 +522,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;
         }