Add changelog support for add, drop, and later column

4 files changed, 260 insertions, 6 deletions

diff --git a/odb/semantics/relational/column.cxx b/odb/semantics/relational/column.cxx
index 05b8eff..f90b94e 100644
--- a/odb/semantics/relational/column.cxx
+++ b/odb/semantics/relational/column.cxx
@@ -10,6 +10,8 @@ namespace semantics
 {
   namespace relational
   {
+    // column
+    //
     column::
     column (column const& c, uscope&, graph& g)
         : unameable (c, g),
@@ -41,6 +43,13 @@ namespace semantics
     serialize (xml::serializer& s) const
     {
       s.start_element (xmlns, "column");
+      serialize_attributes (s);
+      s.end_element ();
+    }
+
+    void column::
+    serialize_attributes (xml::serializer& s) const
+    {
       unameable::serialize_attributes (s);
 
       s.attribute ("type", type ());
@@ -51,6 +60,80 @@ namespace semantics
 
       if (!options ().empty ())
         s.attribute ("options", options ());
+    }
+
+    // add_column
+    //
+    add_column& add_column::
+    clone (uscope& s, graph& g) const
+    {
+      return g.new_node<add_column> (*this, s, g);
+    }
+
+    void add_column::
+    serialize (xml::serializer& s) const
+    {
+      s.start_element (xmlns, "add-column");
+      column::serialize_attributes (s);
+      s.end_element ();
+    }
+
+    // drop_column
+    //
+    drop_column::
+    drop_column (xml::parser& p, uscope&, graph& g)
+        : unameable (p, g)
+    {
+      p.content (xml::parser::empty);
+    }
+
+    drop_column& drop_column::
+    clone (uscope& s, graph& g) const
+    {
+      return g.new_node<drop_column> (*this, s, g);
+    }
+
+    void drop_column::
+    serialize (xml::serializer& s) const
+    {
+      s.start_element (xmlns, "drop-column");
+      unameable::serialize_attributes (s);
+      s.end_element ();
+    }
+
+    // alter_column
+    //
+    alter_column::
+    alter_column (alter_column const& ac, uscope&, graph& g)
+        : unameable (ac, g),
+          null_altered_ (ac.null_altered_),
+          null_ (ac.null_)
+    {
+    }
+
+    alter_column::
+    alter_column (xml::parser& p, uscope&, graph& g)
+        : unameable (p, g),
+          null_altered_ (p.attribute_present ("null")),
+          null_ (null_altered_ ? p.attribute<bool> ("null") : false)
+    {
+      p.content (xml::parser::empty);
+    }
+
+    alter_column& alter_column::
+    clone (uscope& s, graph& g) const
+    {
+      return g.new_node<alter_column> (*this, s, g);
+    }
+
+    void alter_column::
+    serialize (xml::serializer& s) const
+    {
+      s.start_element (xmlns, "alter-column");
+      unameable::serialize_attributes (s);
+
+      if (null_altered_)
+        s.attribute ("null", null_);
 
       s.end_element ();
     }
@@ -63,15 +146,46 @@ namespace semantics
       {
         init ()
         {
-          unameable::parser_map_["column"] = &unameable::parser_impl<column>;
+          unameable::parser_map& m (unameable::parser_map_);
+
+          m["column"] = &unameable::parser_impl<column>;
+          m["add-column"] = &unameable::parser_impl<add_column>;
+          m["drop-column"] = &unameable::parser_impl<drop_column>;
+          m["alter-column"] = &unameable::parser_impl<alter_column>;
 
           using compiler::type_info;
 
+          // column
+          //
           {
             type_info ti (typeid (column));
             ti.add_base (typeid (unameable));
             insert (ti);
           }
+
+          // add_column
+          //
+          {
+            type_info ti (typeid (add_column));
+            ti.add_base (typeid (column));
+            insert (ti);
+          }
+
+          // drop_column
+          //
+          {
+            type_info ti (typeid (drop_column));
+            ti.add_base (typeid (unameable));
+            insert (ti);
+          }
+
+          // alter_column
+          //
+          {
+            type_info ti (typeid (alter_column));
+            ti.add_base (typeid (unameable));
+            insert (ti);
+          }
         }
       } init_;
     }
diff --git a/odb/semantics/relational/column.hxx b/odb/semantics/relational/column.hxx
index 07d61bf..7702a13 100644
--- a/odb/semantics/relational/column.hxx
+++ b/odb/semantics/relational/column.hxx
@@ -25,6 +25,9 @@ namespace semantics
       bool
       null () const {return null_;}
 
+      void
+      null (bool n) {null_ = n;}
+
       string const&
       default_ () const {return default__;}
 
@@ -88,6 +91,10 @@ namespace semantics
       virtual void
       serialize (xml::serializer&) const;
 
+    protected:
+      void
+      serialize_attributes (xml::serializer&) const;
+
     private:
       string type_;
       bool null_;
@@ -96,6 +103,80 @@ namespace semantics
 
       contained_list contained_;
     };
+
+    class add_column: public column
+    {
+    public:
+      add_column (string const& id, string const& type, bool null)
+          : column (id, type, null) {}
+      add_column (column const& c, uscope& s, graph& g): column (c, s, g) {}
+      add_column (xml::parser& p, uscope& s, graph& g): column (p, s, g) {}
+
+      virtual add_column&
+      clone (uscope&, graph&) const;
+
+      virtual string
+      kind () const {return "add column";}
+
+      virtual void
+      serialize (xml::serializer&) const;
+    };
+
+    class drop_column: public unameable
+    {
+    public:
+      drop_column (string const& id): unameable (id) {}
+      drop_column (drop_column const& c, uscope&, graph& g)
+          : unameable (c, g) {}
+      drop_column (xml::parser&, uscope&, graph&);
+
+      virtual drop_column&
+      clone (uscope&, graph&) const;
+
+      virtual string
+      kind () const {return "drop column";}
+
+      virtual void
+      serialize (xml::serializer&) const;
+    };
+
+    class alter_column: public unameable
+    {
+    public:
+      bool
+      null_altered () const {return null_altered_;}
+
+      bool
+      null () const {return null_;}
+
+      void
+      null (bool n) {null_ = n; null_altered_ = true;}
+
+    public:
+      alter_column (string const& id)
+          : unameable (id), null_altered_ (false)
+      {
+      }
+
+      alter_column (alter_column const&, uscope&, graph&);
+      alter_column (xml::parser&, uscope&, graph&);
+
+      virtual alter_column&
+      clone (uscope&, graph&) const;
+
+      virtual string
+      kind () const
+      {
+        return "alter column";
+      }
+
+      virtual void
+      serialize (xml::serializer&) const;
+
+    private:
+      bool null_altered_;
+      bool null_;
+    };
   }
 }
 
diff --git a/odb/semantics/relational/table.cxx b/odb/semantics/relational/table.cxx
index 6d1c3a2..682196c 100644
--- a/odb/semantics/relational/table.cxx
+++ b/odb/semantics/relational/table.cxx
@@ -79,6 +79,35 @@ namespace semantics
       s.end_element ();
     }
 
+    // alter_table
+    //
+    alter_table::
+    alter_table (alter_table const& t, qscope&, graph& g)
+        : qnameable (t, g), uscope (t, g)
+    {
+    }
+
+    alter_table::
+    alter_table (xml::parser& p, qscope&, graph& g)
+        : qnameable (p, g), uscope (p, g)
+    {
+    }
+
+    alter_table& alter_table::
+    clone (qscope& s, graph& g) const
+    {
+      return g.new_node<alter_table> (*this, s, g);
+    }
+
+    void alter_table::
+    serialize (xml::serializer& s) const
+    {
+      s.start_element (xmlns, "alter-table");
+      qnameable::serialize_attributes (s);
+      uscope::serialize_content (s);
+      s.end_element ();
+    }
+
     // type info
     //
     namespace
@@ -87,11 +116,12 @@ namespace semantics
       {
         init ()
         {
-          qnameable::parser_map_["table"] = &qnameable::parser_impl<table>;
-          qnameable::parser_map_["add-table"] =
-            &qnameable::parser_impl<add_table>;
-          qnameable::parser_map_["drop-table"] =
-            &qnameable::parser_impl<drop_table>;
+          qnameable::parser_map& m (qnameable::parser_map_);
+
+          m["table"] = &qnameable::parser_impl<table>;
+          m["add-table"] = &qnameable::parser_impl<add_table>;
+          m["drop-table"] = &qnameable::parser_impl<drop_table>;
+          m["alter-table"] = &qnameable::parser_impl<alter_table>;
 
           using compiler::type_info;
 
@@ -119,6 +149,15 @@ namespace semantics
             ti.add_base (typeid (qnameable));
             insert (ti);
           }
+
+          // alter_table
+          //
+          {
+            type_info ti (typeid (alter_table));
+            ti.add_base (typeid (qnameable));
+            ti.add_base (typeid (uscope));
+            insert (ti);
+          }
         }
       } init_;
     }
diff --git a/odb/semantics/relational/table.hxx b/odb/semantics/relational/table.hxx
index 3eb1b73..effd552 100644
--- a/odb/semantics/relational/table.hxx
+++ b/odb/semantics/relational/table.hxx
@@ -66,6 +66,26 @@ namespace semantics
       serialize (xml::serializer&) const;
     };
 
+    class alter_table: public qnameable, public uscope
+    {
+    public:
+      alter_table (string const& id): qnameable (id) {}
+      alter_table (alter_table const&, qscope&, graph&);
+      alter_table (xml::parser&, qscope&, graph&);
+
+      virtual alter_table&
+      clone (qscope&, graph&) const;
+
+      virtual string
+      kind () const {return "alter table";}
+
+      virtual void
+      serialize (xml::serializer&) const;
+
+      // Resolve ambiguity.
+      //
+      using qnameable::scope;
+    };
   }
 }