Add PostgreSQL common implementation

2 files changed, 592 insertions, 0 deletions

diff --git a/odb/relational/pgsql/common.cxx b/odb/relational/pgsql/common.cxx
new file mode 100644
index 0000000..d1b5474
--- /dev/null
+++ b/odb/relational/pgsql/common.cxx
@@ -0,0 +1,378 @@
+// file      : odb/relational/pgsql/common.cxx
+// author    : Constantin Michael <constantin@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#include <cassert>
+
+#include <odb/relational/pgsql/common.hxx>
+
+using namespace std;
+
+namespace relational
+{
+  namespace pgsql
+  {
+    //
+    // member_base
+    //
+
+    void member_base::
+    traverse (semantics::data_member& m)
+    {
+      if (m.count ("transient"))
+        return;
+
+      string var;
+
+      if (!var_override_.empty ())
+        var = var_override_;
+      else
+      {
+        string const& name (m.name ());
+        var = name + (name[name.size () - 1] == '_' ? "" : "_");
+      }
+
+      semantics::type& t (type_override_ != 0 ? *type_override_ : m.type ());
+
+      if (comp_value (t))
+      {
+        member_info mi (m, t, var, fq_type_override_);
+        if (pre (mi))
+        {
+          traverse_composite (mi);
+          post (mi);
+        }
+      }
+      else if (container (t))
+      {
+        member_info mi (m, t, var, fq_type_override_);
+        if (pre (mi))
+        {
+          traverse_container (mi);
+          post (mi);
+        }
+      }
+      else
+      {
+        sql_type const& st (column_sql_type (m, key_prefix_));
+
+        if (semantics::class_* c = object_pointer (t))
+        {
+          member_info mi (m, id_member (*c)->type (), var, fq_type_override_);
+          mi.st = &st;
+          if (pre (mi))
+          {
+            traverse_object_pointer (mi);
+            post (mi);
+          }
+        }
+        else
+        {
+          member_info mi (m, t, var, fq_type_override_);
+          mi.st = &st;
+          if (pre (mi))
+          {
+            traverse_simple (mi);
+            post (mi);
+          }
+        }
+      }
+    }
+
+    void member_base::
+    traverse_simple (member_info& mi)
+    {
+      switch (mi.st->type)
+      {
+        // Integral types.
+        //
+      case sql_type::BOOLEAN:
+      case sql_type::SMALLINT:
+      case sql_type::INTEGER:
+      case sql_type::BIGINT:
+        {
+          traverse_integer (mi);
+          break;
+        }
+
+        // Float types.
+        //
+      case sql_type::REAL:
+      case sql_type::DOUBLE:
+        {
+          traverse_float (mi);
+          break;
+        }
+      case sql_type::NUMERIC:
+        {
+          traverse_numeric (mi);
+          break;
+        }
+
+        // Data-time types.
+        //
+      case sql_type::DATE:
+      case sql_type::TIME:
+      case sql_type::TIMESTAMP:
+        {
+          traverse_date_time (mi);
+          break;
+        }
+
+        // String and binary types.
+        //
+      case sql_type::CHAR:
+      case sql_type::VARCHAR:
+      case sql_type::TEXT:
+      case sql_type::BYTEA:
+        {
+          traverse_string (mi);
+          break;
+        }
+      case sql_type::BIT:
+        {
+          traverse_bit (mi);
+          break;
+        }
+      case sql_type::VARBIT:
+        {
+          traverse_varbit (mi);
+          break;
+        }
+        // Other types.
+        //
+      case sql_type::UUID:
+        {
+          traverse_uuid (mi);
+          break;
+        }
+      case sql_type::invalid:
+        {
+          assert (false);
+          break;
+        }
+      }
+    }
+
+    //
+    // member_image_type
+    //
+
+    namespace
+    {
+      const char* integer_types[] =
+      {
+        "bool",
+        "short",
+        "int",
+        "long long"
+      };
+
+      const char* float_types[] =
+      {
+        "float",
+        "double"
+      };
+    }
+
+    member_image_type::
+    member_image_type (semantics::type* type,
+                       string const& fq_type,
+                       string const& key_prefix)
+        : relational::member_base (type, fq_type, key_prefix)
+    {
+    }
+
+    string member_image_type::
+    image_type (semantics::data_member& m)
+    {
+      type_.clear ();
+      member_base::traverse (m);
+      return type_;
+    }
+
+    void member_image_type::
+    traverse_composite (member_info& mi)
+    {
+      type_ = "composite_value_traits< " + mi.fq_type () + " >::image_type";
+    }
+
+    void member_image_type::
+    traverse_integer (member_info& mi)
+    {
+      type_ += integer_types[mi.st->type - sql_type::BOOLEAN];
+    }
+
+    void member_image_type::
+    traverse_float (member_info& mi)
+    {
+      type_ = float_types[mi.st->type - sql_type::REAL];
+    }
+
+    void member_image_type::
+    traverse_numeric (member_info&)
+    {
+      type_ = "details::buffer";
+    }
+
+    void member_image_type::
+    traverse_date_time (member_info&)
+    {
+      type_ = "details::buffer";
+    }
+
+    void member_image_type::
+    traverse_string (member_info&)
+    {
+      type_ = "details::buffer";
+    }
+
+    void member_image_type::
+    traverse_bit (member_info&)
+    {
+      type_ = "unsigned char*";
+    }
+
+    void member_image_type::
+    traverse_varbit (member_info&)
+    {
+      type_ = "details::buffer";
+    }
+
+    void member_image_type::
+    traverse_uuid (member_info&)
+    {
+      type_ = "unsigned char*";
+    }
+
+    //
+    // member_database_type
+    //
+
+    namespace
+    {
+      const char* integer_database_id[] =
+      {
+        "id_boolean",
+        "id_smallint",
+        "id_integer",
+        "id_bigint"
+      };
+
+      const char* float_database_id[] =
+      {
+        "id_real",
+        "id_double"
+      };
+
+      const char* date_time_database_id[] =
+      {
+        "id_date",
+        "id_time",
+        "id_timestamp"
+      };
+
+      const char* char_bin_database_id[] =
+      {
+        "id_string",  // CHAR
+        "id_string",  // VARCHAR
+        "id_string",  // TEXT,
+        "id_bytea"    // BYTEA
+      };
+   }
+
+    member_database_type_id::
+    member_database_type_id (semantics::type* type,
+                          string const& fq_type,
+                          string const& key_prefix)
+        : relational::member_base (type, fq_type, key_prefix)
+    {
+    }
+
+    string member_database_type_id::
+    database_type_id (type& m)
+    {
+      type_id_.clear ();
+      member_base::traverse (m);
+      return type_id_;
+    }
+
+    void member_database_type_id::
+    traverse_composite (member_info&)
+    {
+      assert (false);
+    }
+
+    void member_database_type_id::
+    traverse_integer (member_info& mi)
+    {
+      type_id_ = string ("pgsql::") +
+        integer_database_id[mi.st->type - sql_type::BOOLEAN];
+    }
+
+    void member_database_type_id::
+    traverse_float (member_info& mi)
+    {
+      type_id_ = string ("pgsql::") +
+        float_database_id[mi.st->type - sql_type::REAL];
+    }
+
+    void member_database_type_id::
+    traverse_numeric (member_info&)
+    {
+      type_id_ = "pgsql::id_numeric";
+    }
+
+    void member_database_type_id::
+    traverse_date_time (member_info& mi)
+    {
+      type_id_ = string ("pgsql::") +
+        date_time_database_id[mi.st->type - sql_type::DATE];
+    }
+
+    void member_database_type_id::
+    traverse_string (member_info& mi)
+    {
+      type_id_ = string ("pgsql::") +
+        char_bin_database_id[mi.st->type - sql_type::CHAR];
+    }
+
+    void member_database_type_id::
+    traverse_bit (member_info&)
+    {
+      type_id_ = "pgsql::id_bit";
+    }
+
+    void member_database_type_id::
+    traverse_varbit (member_info&)
+    {
+      type_id_ = "pgsql::id_varbit";
+    }
+
+    void member_database_type_id::
+    traverse_uuid (member_info&)
+    {
+      type_id_ = "pgsql::id_uuid";
+    }
+
+    //
+    // query_columns
+    //
+
+    struct query_columns: relational::query_columns, context
+    {
+      query_columns (base const& x): base (x) {}
+
+      virtual string
+      database_type_id (semantics::data_member& m)
+      {
+        return member_database_type_id_.database_type_id (m);
+      }
+
+    private:
+      member_database_type_id member_database_type_id_;
+    };
+    entry<query_columns> query_columns_;
+  }
+}
diff --git a/odb/relational/pgsql/common.hxx b/odb/relational/pgsql/common.hxx
new file mode 100644
index 0000000..52fcd2d
--- /dev/null
+++ b/odb/relational/pgsql/common.hxx
@@ -0,0 +1,214 @@
+// file      : odb/relational/pgsql/common.hxx
+// author    : Constantin Michael <constantin@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#ifndef ODB_RELATIONAL_PGSQL_COMMON_HXX
+#define ODB_RELATIONAL_PGSQL_COMMON_HXX
+
+#include <odb/relational/common.hxx>
+#include <odb/relational/pgsql/context.hxx>
+
+namespace relational
+{
+  namespace pgsql
+  {
+    struct member_base: virtual relational::member_base, context
+    {
+      member_base (base const& x): base (x) {}
+
+      // This c-tor is for the direct use inside the pgsql namespace.
+      // If you do use this c-tor, you should also explicitly call
+      // relational::member_base.
+      //
+      member_base () {}
+
+      virtual void
+      traverse (semantics::data_member& m);
+
+      struct member_info
+      {
+        semantics::data_member& m; // Member.
+        semantics::type& t;        // Member C++ type (m.type () may != t).
+        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
+        {
+          // 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.
+          //
+          return fq_type_.empty ()
+            ? m.type ().fq_name (m.belongs ().hint ())
+            : fq_type_;
+        }
+
+        string const& fq_type_;
+
+        member_info (semantics::data_member& m_,
+                     semantics::type& t_,
+                     string& var_,
+                     string const& fq_type)
+            : m (m_), t (t_), st (0), var (var_), fq_type_ (fq_type)
+        {
+        }
+      };
+
+      // The false return value indicates that no further callbacks
+      // should be called for this member.
+      //
+      virtual bool
+      pre (member_info&)
+      {
+        return true;
+      }
+
+      virtual void
+      post (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_composite (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_container (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_object_pointer (member_info& mi)
+      {
+        traverse_simple (mi);
+      }
+
+      virtual void
+      traverse_simple (member_info&);
+
+      virtual void
+      traverse_integer (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_float (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_numeric (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_date_time (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_string (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_bit (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_varbit (member_info&)
+      {
+      }
+
+      virtual void
+      traverse_uuid (member_info&)
+      {
+      }
+    };
+
+    struct member_image_type: member_base
+    {
+      member_image_type (semantics::type* type = 0,
+                         string const& fq_type = string (),
+                         string const& key_prefix = string ());
+      string
+      image_type (semantics::data_member&);
+
+      virtual void
+      traverse_composite (member_info&);
+
+      virtual void
+      traverse_integer (member_info&);
+
+      virtual void
+      traverse_float (member_info&);
+
+      virtual void
+      traverse_numeric (member_info&);
+
+      virtual void
+      traverse_date_time (member_info&);
+
+      virtual void
+      traverse_string (member_info&);
+
+      virtual void
+      traverse_bit (member_info&);
+
+      virtual void
+      traverse_varbit (member_info&);
+
+      virtual void
+      traverse_uuid (member_info&);
+
+    private:
+      string type_;
+    };
+
+    struct member_database_type_id: member_base
+    {
+      member_database_type_id (semantics::type* type = 0,
+                               string const& fq_type = string (),
+                               string const& key_prefix = string ());
+      string
+      database_type_id (type&);
+
+      virtual void
+      traverse_composite (member_info&);
+
+      virtual void
+      traverse_integer (member_info&);
+
+      virtual void
+      traverse_float (member_info&);
+
+      virtual void
+      traverse_numeric (member_info&);
+
+      virtual void
+      traverse_date_time (member_info&);
+
+      virtual void
+      traverse_string (member_info&);
+
+      virtual void
+      traverse_bit (member_info&);
+
+      virtual void
+      traverse_varbit (member_info&);
+
+      virtual void
+      traverse_uuid (member_info&);
+
+    private:
+      string type_id_;
+    };
+  }
+}
+#endif // ODB_RELATIONAL_PGSQL_COMMON_HXX