From 8295d4bd02946b7bdbff2a9cfa7763232e2d2fd0 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Mon, 8 Apr 2013 14:34:57 +0200
Subject: Clean up class order in schema generators

---
 odb/relational/mssql/schema.cxx  | 32 ++++++++------
 odb/relational/mysql/schema.cxx  | 93 ++++++++++++++++++++-------------------
 odb/relational/oracle/schema.cxx | 70 ++++++++++++++++--------------
 odb/relational/pgsql/schema.cxx  |  4 ++
 odb/relational/schema.hxx        |  2 +-
 odb/relational/sqlite/schema.cxx | 94 ++++++++++++++++++++++------------------
 6 files changed, 160 insertions(+), 135 deletions(-)

diff --git a/odb/relational/mssql/schema.cxx b/odb/relational/mssql/schema.cxx
index 7458d3e..3528de9 100644
--- a/odb/relational/mssql/schema.cxx
+++ b/odb/relational/mssql/schema.cxx
@@ -141,6 +141,21 @@ namespace relational
       };
       entry<drop_foreign_key> drop_foreign_key_;
 
+      struct drop_index: relational::drop_index, context
+      {
+        drop_index (base const& x): base (x) {}
+
+        virtual void
+        drop (sema_rel::index& in)
+        {
+          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
+
+          os << "DROP INDEX " << name (in) << " ON " <<
+            quote_id (t.name ()) << endl;
+        }
+      };
+      entry<drop_index> drop_index_;
+
       struct drop_table: relational::drop_table, context
       {
         drop_table (base const& x): base (x) {}
@@ -339,20 +354,9 @@ namespace relational
       };
       entry<create_table> create_table_;
 
-      struct drop_index: relational::drop_index, context
-      {
-        drop_index (base const& x): base (x) {}
-
-        virtual void
-        drop (sema_rel::index& in)
-        {
-          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
-
-          os << "DROP INDEX " << name (in) << " ON " <<
-            quote_id (t.name ()) << endl;
-        }
-      };
-      entry<drop_index> drop_index_;
+      //
+      // Alter.
+      //
 
       struct alter_column: relational::alter_column, context
       {
diff --git a/odb/relational/mysql/schema.cxx b/odb/relational/mysql/schema.cxx
index 9b04e6b..8e71f92 100644
--- a/odb/relational/mysql/schema.cxx
+++ b/odb/relational/mysql/schema.cxx
@@ -21,6 +21,7 @@ namespace relational
       //
       // Drop.
       //
+
       struct drop_foreign_key: relational::drop_foreign_key, context
       {
         drop_foreign_key (base const& x): base (x) {}
@@ -109,6 +110,21 @@ namespace relational
       };
       entry<drop_foreign_key> drop_foreign_key_;
 
+      struct drop_index: relational::drop_index, context
+      {
+        drop_index (base const& x): base (x) {}
+
+        virtual void
+        drop (sema_rel::index& in)
+        {
+          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
+
+          os << "DROP INDEX " << name (in) << " ON " <<
+            quote_id (t.name ()) << endl;
+        }
+      };
+      entry<drop_index> drop_index_;
+
       //
       // Create.
       //
@@ -184,6 +200,36 @@ namespace relational
       };
       entry<create_foreign_key> create_foreign_key_;
 
+      struct create_index: relational::create_index, context
+      {
+        create_index (base const& x): base (x) {}
+
+        virtual void
+        create (sema_rel::index& in)
+        {
+          os << "CREATE ";
+
+          if (!in.type ().empty ())
+            os << in.type () << ' ';
+
+          os << "INDEX " << name (in);
+
+          if (!in.method ().empty ())
+            os << " USING " << in.method ();
+
+          os << endl
+             << "  ON " << table_name (in) << " (";
+
+          columns (in);
+
+          os << ")" << endl;
+
+          if (!in.options ().empty ())
+            os << ' ' << in.options () << endl;
+        }
+      };
+      entry<create_index> create_index_;
+
       struct create_table: relational::create_table, context
       {
         create_table (base const& x): base (x) {}
@@ -268,50 +314,9 @@ namespace relational
       };
       entry<create_table> create_table_;
 
-      struct create_index: relational::create_index, context
-      {
-        create_index (base const& x): base (x) {}
-
-        virtual void
-        create (sema_rel::index& in)
-        {
-          os << "CREATE ";
-
-          if (!in.type ().empty ())
-            os << in.type () << ' ';
-
-          os << "INDEX " << name (in);
-
-          if (!in.method ().empty ())
-            os << " USING " << in.method ();
-
-          os << endl
-             << "  ON " << table_name (in) << " (";
-
-          columns (in);
-
-          os << ")" << endl;
-
-          if (!in.options ().empty ())
-            os << ' ' << in.options () << endl;
-        }
-      };
-      entry<create_index> create_index_;
-
-      struct drop_index: relational::drop_index, context
-      {
-        drop_index (base const& x): base (x) {}
-
-        virtual void
-        drop (sema_rel::index& in)
-        {
-          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
-
-          os << "DROP INDEX " << name (in) << " ON " <<
-            quote_id (t.name ()) << endl;
-        }
-      };
-      entry<drop_index> drop_index_;
+      //
+      // Alter.
+      //
 
       struct alter_column: relational::alter_column, context
       {
diff --git a/odb/relational/oracle/schema.cxx b/odb/relational/oracle/schema.cxx
index 68dab57..a49ace0 100644
--- a/odb/relational/oracle/schema.cxx
+++ b/odb/relational/oracle/schema.cxx
@@ -118,6 +118,23 @@ namespace relational
       };
       entry<drop_foreign_key> drop_foreign_key_;
 
+      struct drop_index: relational::drop_index, context
+      {
+        drop_index (base const& x): base (x) {}
+
+        virtual string
+        name (sema_rel::index& in)
+        {
+          // In Oracle, index names can be qualified with the schema.
+          //
+          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
+          sema_rel::qname n (t.name ().qualifier ());
+          n.append (in.name ());
+          return quote_id (n);
+        }
+      };
+      entry<drop_index> drop_index_;
+
       struct drop_table: relational::drop_table, context
       {
         drop_table (base const& x): base (x) {}
@@ -251,6 +268,23 @@ namespace relational
       };
       entry<create_foreign_key> create_foreign_key_;
 
+      struct create_index: relational::create_index, context
+      {
+        create_index (base const& x): base (x) {}
+
+        virtual string
+        name (sema_rel::index& in)
+        {
+          // In Oracle, index names can be qualified with the schema.
+          //
+          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
+          sema_rel::qname n (t.name ().qualifier ());
+          n.append (in.name ());
+          return quote_id (n);
+        }
+      };
+      entry<create_index> create_index_;
+
       struct create_table: relational::create_table, context
       {
         create_table (base const& x): base (x) {}
@@ -284,39 +318,9 @@ namespace relational
       };
       entry<create_table> create_table_;
 
-      struct create_index: relational::create_index, context
-      {
-        create_index (base const& x): base (x) {}
-
-        virtual string
-        name (sema_rel::index& in)
-        {
-          // In Oracle, index names can be qualified with the schema.
-          //
-          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
-          sema_rel::qname n (t.name ().qualifier ());
-          n.append (in.name ());
-          return quote_id (n);
-        }
-      };
-      entry<create_index> create_index_;
-
-      struct drop_index: relational::drop_index, context
-      {
-        drop_index (base const& x): base (x) {}
-
-        virtual string
-        name (sema_rel::index& in)
-        {
-          // In Oracle, index names can be qualified with the schema.
-          //
-          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
-          sema_rel::qname n (t.name ().qualifier ());
-          n.append (in.name ());
-          return quote_id (n);
-        }
-      };
-      entry<drop_index> drop_index_;
+      //
+      // Alter.
+      //
 
       struct alter_column: relational::alter_column, context
       {
diff --git a/odb/relational/pgsql/schema.cxx b/odb/relational/pgsql/schema.cxx
index 6d44139..77216af 100644
--- a/odb/relational/pgsql/schema.cxx
+++ b/odb/relational/pgsql/schema.cxx
@@ -134,6 +134,10 @@ namespace relational
       };
       entry<create_index> create_index_;
 
+      //
+      // Alter.
+      //
+
       struct alter_column: relational::alter_column, context
       {
         alter_column (base const& x): base (x) {}
diff --git a/odb/relational/schema.hxx b/odb/relational/schema.hxx
index df395b8..2cff998 100644
--- a/odb/relational/schema.hxx
+++ b/odb/relational/schema.hxx
@@ -1065,7 +1065,7 @@ namespace relational
     };
 
     //
-    // Migration.
+    // Alter.
     //
 
     struct alter_column: trav_rel::alter_column,
diff --git a/odb/relational/sqlite/schema.cxx b/odb/relational/sqlite/schema.cxx
index 92f6764..6c5b525 100644
--- a/odb/relational/sqlite/schema.cxx
+++ b/odb/relational/sqlite/schema.cxx
@@ -16,6 +16,45 @@ namespace relational
       namespace relational = relational::schema;
 
       //
+      // Drop.
+      //
+
+      struct drop_index: relational::drop_index, context
+      {
+        drop_index (base const& x): base (x) {}
+
+        virtual string
+        name (sema_rel::index& in)
+        {
+          // In SQLite, index names can be qualified with the database.
+          //
+          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
+          sema_rel::qname n (t.name ().qualifier ());
+          n.append (in.name ());
+          return quote_id (n);
+        }
+      };
+      entry<drop_index> drop_index_;
+
+      struct drop_table: relational::drop_table, context
+      {
+        drop_table (base const& x): base (x) {}
+
+        virtual void
+        traverse (sema_rel::table& t, bool migration)
+        {
+          // In SQLite there is no way to drop foreign keys except as part
+          // of the table.
+          //
+          if (pass_ != 2)
+            return;
+
+          drop (t.name (), migration);
+        }
+      };
+      entry<drop_table> drop_table_;
+
+      //
       // Create.
       //
 
@@ -114,22 +153,6 @@ namespace relational
       };
       entry<create_foreign_key> create_foreign_key_;
 
-      struct create_table: relational::create_table, context
-      {
-        create_table (base const& x): base (x) {}
-
-        void
-        traverse (sema_rel::table& t)
-        {
-          // For SQLite we do everything in a single pass since there
-          // is no way to add constraints later.
-          //
-          if (pass_ == 1)
-            create (t);
-        }
-      };
-      entry<create_table> create_table_;
-
       struct create_index: relational::create_index, context
       {
         create_index (base const& x): base (x) {}
@@ -157,40 +180,25 @@ namespace relational
       };
       entry<create_index> create_index_;
 
-      struct drop_index: relational::drop_index, context
+      struct create_table: relational::create_table, context
       {
-        drop_index (base const& x): base (x) {}
+        create_table (base const& x): base (x) {}
 
-        virtual string
-        name (sema_rel::index& in)
+        void
+        traverse (sema_rel::table& t)
         {
-          // In SQLite, index names can be qualified with the database.
+          // For SQLite we do everything in a single pass since there
+          // is no way to add constraints later.
           //
-          sema_rel::table& t (static_cast<sema_rel::table&> (in.scope ()));
-          sema_rel::qname n (t.name ().qualifier ());
-          n.append (in.name ());
-          return quote_id (n);
+          if (pass_ == 1)
+            create (t);
         }
       };
-      entry<drop_index> drop_index_;
-
-      struct drop_table: relational::drop_table, context
-      {
-        drop_table (base const& x): base (x) {}
-
-        virtual void
-        traverse (sema_rel::table& t, bool migration)
-        {
-          // In SQLite there is no way to drop foreign keys except as part
-          // of the table.
-          //
-          if (pass_ != 2)
-            return;
+      entry<create_table> create_table_;
 
-          drop (t.name (), migration);
-        }
-      };
-      entry<drop_table> drop_table_;
+      //
+      // Alter.
+      //
 
       struct alter_table_pre: relational::alter_table_pre, context
       {
-- 
cgit v1.1