Implement summary soft-deletion for composite value types

2 files changed, 180 insertions, 0 deletions

diff --git a/evolution/soft-delete/driver.cxx b/evolution/soft-delete/driver.cxx
index 7c53f28..7fc7b49 100644
--- a/evolution/soft-delete/driver.cxx
+++ b/evolution/soft-delete/driver.cxx
@@ -262,6 +262,24 @@ main (int argc, char* argv[])
           }
         }
 
+        // Test summarily deleted composite values.
+        //
+        {
+          using namespace test15;
+
+          object o (1);
+          o.v.reset (new value);
+          o.v->str = "abc";
+          o.v->vec.push_back (123);
+          o.num = 123;
+
+          {
+            transaction t (db->begin ());
+            db->persist (o);
+            t.commit ();
+          }
+        }
+
         // Test soft-deleted container member in a non-versioned object.
         //
         {
@@ -929,6 +947,70 @@ main (int argc, char* argv[])
           }
         }
 
+        // Test summarily deleted composite values.
+        //
+        {
+          using namespace test15;
+
+          // All the database operations should still include the deleted
+          // members.
+          //
+          {
+            transaction t (db->begin ());
+            auto_ptr<object> p (db->load<object> (1));
+            assert (p->v->str == "abc" && p->num == 123 &&
+                    p->v->vec[0] == 123);
+            t.commit ();
+          }
+
+          {
+            typedef odb::query<object> query;
+            typedef odb::result<object> result;
+
+            transaction t (db->begin ());
+            result r (db->query<object> (query::v.str == "abc"));
+            result::iterator i (r.begin ());
+            assert (i != r.end () &&
+                    i->v->str == "abc" && i->num == 123 &&
+                    i->v->vec[0] == 123);
+            t.commit ();
+          }
+
+          object o (2);
+          o.v.reset (new value);
+          o.v->str = "bcd";
+          o.num = 234;
+          o.v->vec.push_back (234);
+
+          {
+            transaction t (db->begin ());
+            db->persist (o);
+            auto_ptr<object> p (db->load<object> (2));
+            assert (p->v->str == "bcd" && p->num == 234 &&
+                    p->v->vec[0] == 234);
+            t.commit ();
+          }
+
+          o.v->str += 'e';
+          o.num++;
+          o.v->vec.modify (0)++;
+
+          {
+            transaction t (db->begin ());
+            db->update (o);
+            auto_ptr<object> p (db->load<object> (2));
+            assert (p->v->str == "bcde" && p->num == 235 &&
+                    p->v->vec[0] == 235);
+            t.commit ();
+          }
+
+          {
+            transaction t (db->begin ());
+            db->erase (o);
+            t.commit ();
+          }
+        }
+
         // Test soft-deleted container member in a non-versioned object.
         //
         {
@@ -1901,6 +1983,73 @@ main (int argc, char* argv[])
           }
         }
 
+        // Test summarily deleted composite values.
+        //
+        {
+          using namespace test15;
+
+          // Now none of the database operations should include the
+          // deleted members.
+          //
+          {
+            transaction t (db->begin ());
+            auto_ptr<object> p (db->load<object> (1));
+            assert (p->v.get () == 0 && p->num == 123);
+            t.commit ();
+          }
+
+          {
+            typedef odb::query<object> query;
+            typedef odb::result<object> result;
+
+            transaction t (db->begin ());
+            result r (db->query<object> (query::num == 123));
+            result::iterator i (r.begin ());
+            assert (i != r.end () && i->v.get () == 0 && i->num == 123);
+
+            // Logical delete in SQLite.
+            //
+#ifndef DATABASE_SQLITE
+            try
+            {
+              db->query<object> (query::v.str == "abc"); // No such column.
+              assert (false);
+            }
+            catch (const odb::exception&) {}
+#else
+            assert (size (db->query<object> (query::v.str.is_null ())) == 1);
+#endif
+            t.commit ();
+          }
+
+          object o (2);
+          o.num = 234;
+
+          {
+            transaction t (db->begin ());
+            db->persist (o);
+            auto_ptr<object> p (db->load<object> (2));
+            assert (p->v.get () == 0 && p->num == 234);
+            t.commit ();
+          }
+
+          o.num++;
+
+          {
+            transaction t (db->begin ());
+            db->update (o);
+            auto_ptr<object> p (db->load<object> (2));
+            assert (p->v.get () == 0 && p->num == 235);
+            t.commit ();
+          }
+
+          {
+            transaction t (db->begin ());
+            db->erase<object> (2);
+            t.commit ();
+          }
+        }
+
         // Test soft-deleted container member in a non-versioned object.
         //
         {
diff --git a/evolution/soft-delete/model.hxx b/evolution/soft-delete/model.hxx
index 0a81116..9c99abe 100644
--- a/evolution/soft-delete/model.hxx
+++ b/evolution/soft-delete/model.hxx
@@ -7,6 +7,7 @@
 #endif
 
 #include <string>
+#include <memory> // std::auto_ptr
 
 #include <odb/core.hxx>
 #include <odb/vector.hxx>
@@ -427,6 +428,36 @@ namespace MODEL_NAMESPACE(MODEL_VERSION)
 #endif
   }
 
+  // Test summarily deleted composite values.
+  //
+  #pragma db namespace table("t15_")
+  namespace test15
+  {
+    #pragma db value
+    struct value
+    {
+      std::string str;
+      odb::vector<int> vec;
+    };
+
+    #pragma db object
+    struct object
+    {
+      object (unsigned long id = 0): id_ (id) {}
+
+      #pragma db id
+      unsigned long id_;
+
+      std::auto_ptr<value> v;
+      unsigned long num;
+    };
+
+#if MODEL_VERSION == 3
+    #pragma db member(value::str) deleted(3)
+    #pragma db member(value::vec) deleted(3)
+#endif
+  }
+
   // Test soft-deleted container member in a non-versioned object.
   //
   #pragma db namespace table("t21_")