From a4f25daf17392c9c4b90de60b9d777290706f667 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Mon, 8 Apr 2013 11:13:51 +0200
Subject: Generate add/drop foreign key migration statements

Also add the --fkeys-deferrable-mode option. General schemas generation
rework.
---
 odb/semantics/relational/deferrable.cxx  | 56 ++++++++++++++++++++++++++++++++
 odb/semantics/relational/deferrable.hxx  | 42 ++++++++++++++++++++++++
 odb/semantics/relational/foreign-key.cxx |  8 ++---
 odb/semantics/relational/foreign-key.hxx | 23 +++++++------
 4 files changed, 115 insertions(+), 14 deletions(-)
 create mode 100644 odb/semantics/relational/deferrable.cxx
 create mode 100644 odb/semantics/relational/deferrable.hxx

(limited to 'odb/semantics')

diff --git a/odb/semantics/relational/deferrable.cxx b/odb/semantics/relational/deferrable.cxx
new file mode 100644
index 0000000..6aecb12
--- /dev/null
+++ b/odb/semantics/relational/deferrable.cxx
@@ -0,0 +1,56 @@
+// file      : odb/semantics/relational/deferrable.cxx
+// copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#include <ostream>
+#include <istream>
+
+#include <odb/semantics/relational/deferrable.hxx>
+
+using namespace std;
+
+namespace semantics
+{
+  namespace relational
+  {
+    static const char* deferrable_[] =
+    {
+      "NOT DEFERRABLE",
+      "IMMEDIATE",
+      "DEFERRED"
+    };
+
+    string deferrable::
+    string () const
+    {
+      return deferrable_[v_];
+    }
+
+    ostream&
+    operator<< (ostream& os, deferrable const& v)
+    {
+      return os << v.string ();
+    }
+
+    istream&
+    operator>> (istream& is, deferrable& v)
+    {
+      string s;
+      is >> s;
+
+      if (!is.fail ())
+      {
+        if (s == "not_deferrable" || s == "NOT DEFERRABLE")
+          v = deferrable::not_deferrable;
+        else if (s == "immediate" || s == "IMMEDIATE")
+          v = deferrable::immediate;
+        else if (s == "deferred" || s == "DEFERRED")
+          v = deferrable::deferred;
+        else
+          is.setstate (istream::failbit);
+      }
+
+      return is;
+    }
+  }
+}
diff --git a/odb/semantics/relational/deferrable.hxx b/odb/semantics/relational/deferrable.hxx
new file mode 100644
index 0000000..87d696c
--- /dev/null
+++ b/odb/semantics/relational/deferrable.hxx
@@ -0,0 +1,42 @@
+// file      : odb/semantics/relational/deferrable.hxx
+// copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#ifndef ODB_SEMANTICS_RELATIONAL_DEFERRABLE_HXX
+#define ODB_SEMANTICS_RELATIONAL_DEFERRABLE_HXX
+
+#include <string>
+#include <iosfwd>
+
+namespace semantics
+{
+  namespace relational
+  {
+    struct deferrable
+    {
+      enum value
+      {
+        not_deferrable,
+        immediate,
+        deferred
+      };
+
+      deferrable (value v = value (0)) : v_ (v) {}
+      operator value () const {return v_;}
+
+      std::string
+      string () const;
+
+    private:
+      value v_;
+    };
+
+    std::ostream&
+    operator<< (std::ostream&, deferrable const&);
+
+    std::istream&
+    operator>> (std::istream&, deferrable&);
+  }
+}
+
+#endif // ODB_SEMANTICS_RELATIONAL_DEFERRABLE_HXX
diff --git a/odb/semantics/relational/foreign-key.cxx b/odb/semantics/relational/foreign-key.cxx
index 0407858..8188e1f 100644
--- a/odb/semantics/relational/foreign-key.cxx
+++ b/odb/semantics/relational/foreign-key.cxx
@@ -50,7 +50,7 @@ namespace semantics
         : key (k, s, g),
           referenced_table_ (k.referenced_table_),
           referenced_columns_ (k.referenced_columns_),
-          deferred_ (k.deferred_),
+          deferrable_ (k.deferrable_),
           on_delete_ (k.on_delete_)
     {
     }
@@ -58,7 +58,7 @@ namespace semantics
     foreign_key::
     foreign_key (xml::parser& p, uscope& s, graph& g)
         : key (p, s, g),
-          deferred_ (p.attribute ("deferred", false)),
+          deferrable_ (p.attribute ("deferrable", deferrable_type ())),
           on_delete_ (p.attribute ("on-delete", no_action))
     {
       using namespace xml;
@@ -94,8 +94,8 @@ namespace semantics
     {
       key::serialize_attributes (s);
 
-      if (deferred ())
-        s.attribute ("deferred", true);
+      if (deferrable () != deferrable_type::not_deferrable)
+        s.attribute ("deferrable", deferrable ());
 
       if (on_delete () != no_action)
         s.attribute ("on-delete", on_delete ());
diff --git a/odb/semantics/relational/foreign-key.hxx b/odb/semantics/relational/foreign-key.hxx
index 50a3fae..458683f 100644
--- a/odb/semantics/relational/foreign-key.hxx
+++ b/odb/semantics/relational/foreign-key.hxx
@@ -7,6 +7,7 @@
 
 #include <iosfwd>
 
+#include <odb/semantics/relational/deferrable.hxx>
 #include <odb/semantics/relational/elements.hxx>
 #include <odb/semantics/relational/key.hxx>
 
@@ -38,10 +39,15 @@ namespace semantics
       }
 
     public:
+      typedef relational::deferrable deferrable_type;
+
+      deferrable_type
+      deferrable () const {return deferrable_;}
+
       bool
-      deferred () const
+      not_deferrable () const
       {
-        return deferred_;
+        return deferrable_ == deferrable_type::not_deferrable;
       }
 
       enum action_type
@@ -51,19 +57,16 @@ namespace semantics
       };
 
       action_type
-      on_delete () const
-      {
-        return on_delete_;
-      }
+      on_delete () const {return on_delete_;}
 
     public:
       foreign_key (string const& id,
                    qname const& referenced_table,
-                   bool deferred,
+                   deferrable_type deferrable,
                    action_type on_delete = no_action)
           : key (id),
             referenced_table_ (referenced_table),
-            deferred_ (deferred),
+            deferrable_ (deferrable),
             on_delete_ (on_delete)
       {
       }
@@ -93,7 +96,7 @@ namespace semantics
     private:
       qname referenced_table_;
       columns referenced_columns_;
-      bool deferred_;
+      deferrable_type deferrable_;
       action_type on_delete_;
     };
 
@@ -108,7 +111,7 @@ namespace semantics
     public:
       add_foreign_key (string const& id,
                        qname const& rt,
-                       bool d,
+                       deferrable_type d,
                        action_type od = no_action)
           : foreign_key (id, rt, d, od) {}
       add_foreign_key (foreign_key const& fk, uscope& s, graph& g)
-- 
cgit v1.1