From 304dbce8fa2a5d033870988d17709e3eae050258 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Tue, 10 Jul 2012 15:17:15 +0200
Subject: Add support for custom database type mapping

New pragma qualifier, map, and specifiers: as, to, from. New tests:
<database>/custom.
---
 odb/oracle/details/conversion.hxx | 59 +++++++++++++++++++++++++++++++
 odb/oracle/query.cxx              | 19 +++++++++-
 odb/oracle/query.hxx              | 73 ++++++++++++++++++++++++---------------
 odb/oracle/query.ixx              | 10 +++---
 odb/oracle/query.txx              | 33 +++++++++---------
 5 files changed, 146 insertions(+), 48 deletions(-)
 create mode 100644 odb/oracle/details/conversion.hxx

diff --git a/odb/oracle/details/conversion.hxx b/odb/oracle/details/conversion.hxx
new file mode 100644
index 0000000..d9ea814
--- /dev/null
+++ b/odb/oracle/details/conversion.hxx
@@ -0,0 +1,59 @@
+// file      : odb/oracle/details/conversion.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_ORACLE_DETAILS_CONVERSION_HXX
+#define ODB_ORACLE_DETAILS_CONVERSION_HXX
+
+#include <odb/oracle/traits.hxx>
+
+#include <odb/details/meta/answer.hxx>
+
+namespace odb
+{
+  // @@ Revise this.
+  //
+  namespace details {}
+
+  namespace oracle
+  {
+    namespace details
+    {
+      using namespace odb::details;
+
+      // Detect whether conversion is specified in type_traits.
+      //
+      template <typename T>
+      meta::yes
+      conversion_p_test (typename type_traits<T>::conversion*);
+
+      template <typename T>
+      meta::no
+      conversion_p_test (...);
+
+      template <typename T>
+      struct conversion_p
+      {
+        static const bool value =
+          sizeof (conversion_p_test<T> (0)) == sizeof (meta::yes);
+      };
+
+      template <typename T, bool = conversion_p<T>::value>
+      struct conversion;
+
+      template <typename T>
+      struct conversion<T, true>
+      {
+        static const char* to () {return type_traits<T>::conversion::to ();}
+      };
+
+      template <typename T>
+      struct conversion<T, false>
+      {
+        static const char* to () {return 0;}
+      };
+    }
+  }
+}
+
+#endif // ODB_ORACLE_DETAILS_CONVERSION_HXX
diff --git a/odb/oracle/query.cxx b/odb/oracle/query.cxx
index 53a7991..f2cdac1 100644
--- a/odb/oracle/query.cxx
+++ b/odb/oracle/query.cxx
@@ -119,10 +119,13 @@ namespace odb
     }
 
     void query::
-    add (details::shared_ptr<query_param> p)
+    add (details::shared_ptr<query_param> p, const char* conv)
     {
       clause_.push_back (clause_part (clause_part::param));
 
+      if (conv != 0)
+        clause_.back ().part = conv;
+
       parameters_.push_back (p);
       bind_.push_back (bind ());
       binding_.bind = &bind_[0];
@@ -262,8 +265,22 @@ namespace odb
 
             ostringstream os;
             os << param++;
+
+            // Add the conversion expression, if any.
+            //
+            string::size_type p;
+            if (!i->part.empty ())
+            {
+              p = i->part.find ("(?)");
+              r.append (i->part, 0, p);
+            }
+
             r += ':';
             r += os.str ();
+
+            if (!i->part.empty ())
+              r.append (i->part, p + 3, string::npos);
+
             break;
           }
         case clause_part::native:
diff --git a/odb/oracle/query.hxx b/odb/oracle/query.hxx
index 5d3d7ac..50c9fb3 100644
--- a/odb/oracle/query.hxx
+++ b/odb/oracle/query.hxx
@@ -22,6 +22,7 @@
 #include <odb/details/shared-ptr.hxx>
 
 #include <odb/oracle/details/export.hxx>
+#include <odb/oracle/details/conversion.hxx>
 
 namespace odb
 {
@@ -120,7 +121,7 @@ namespace odb
         clause_part (bool p): kind (boolean), bool_part (p) {}
 
         kind_type kind;
-        std::string part;
+        std::string part; // If kind is param, then part is conversion expr.
         bool bool_part;
       };
 
@@ -163,7 +164,8 @@ namespace odb
       query (val_bind<T> v)
         : binding_ (0, 0)
       {
-        append<T, type_traits<T>::db_type_id> (v);
+        append<T, type_traits<T>::db_type_id> (
+          v, details::conversion<T>::to ());
       }
 
       template <typename T>
@@ -171,7 +173,8 @@ namespace odb
       query (ref_bind<T> r)
         : binding_ (0, 0)
       {
-        append<T, type_traits<T>::db_type_id> (r);
+        append<T, type_traits<T>::db_type_id> (
+          r, details::conversion<T>::to ());
       }
 
       template <database_type_id ID>
@@ -242,7 +245,8 @@ namespace odb
       query&
       operator+= (val_bind<T> v)
       {
-        append<T, type_traits<T>::db_type_id> (v);
+        append<T, type_traits<T>::db_type_id> (
+          v, details::conversion<T>::to ());
         return *this;
       }
 
@@ -250,18 +254,19 @@ namespace odb
       query&
       operator+= (ref_bind<T> r)
       {
-        append<T, type_traits<T>::db_type_id> (r);
+        append<T, type_traits<T>::db_type_id> (
+          r, details::conversion<T>::to ());
         return *this;
       }
 
     public:
       template <typename T, database_type_id ID>
       void
-      append (val_bind<T>);
+        append (val_bind<T>, const char* conv);
 
       template <typename T, database_type_id ID>
       void
-      append (ref_bind<T>);
+        append (ref_bind<T>, const char* conv);
 
       void
       append (const std::string& native);
@@ -271,7 +276,7 @@ namespace odb
 
     private:
       void
-      add (details::shared_ptr<query_param>);
+      add (details::shared_ptr<query_param>, const char* conv);
 
     private:
       typedef std::vector<clause_part> clause_type;
@@ -412,13 +417,16 @@ namespace odb
     template <typename T, database_type_id ID>
     struct query_column
     {
-      // Note that we keep shalow copies of the table and column names.
+      // Note that we keep shalow copies of the table, column, and conversion
+      // expression. The latter can be NULL.
       //
       query_column (const char* table,
                     const char* column,
+                    const char* conv,
                     unsigned short prec = 0xFFF,
                     short scale = 0xFFF)
-          : table_ (table), column_ (column), prec_ (prec), scale_ (scale)
+          : table_ (table), column_ (column), conversion_ (conv),
+            prec_ (prec), scale_ (scale)
       {
       }
 
@@ -434,6 +442,14 @@ namespace odb
         return column_;
       }
 
+      // Can be NULL.
+      //
+      const char*
+      conversion () const
+      {
+        return conversion_;
+      }
+
       unsigned short
       prec () const
       {
@@ -501,7 +517,7 @@ namespace odb
 
         query q (table_, column_);
         q += "=";
-        q.append<T, ID> (v);
+        q.append<T, ID> (v, conversion_);
         return q;
       }
 
@@ -521,7 +537,7 @@ namespace odb
 
         query q (table_, column_);
         q += "=";
-        q.append<T, ID> (r);
+        q.append<T, ID> (r, conversion_);
         return q;
       }
 
@@ -592,7 +608,7 @@ namespace odb
 
         query q (table_, column_);
         q += "!=";
-        q.append<T, ID> (v);
+        q.append<T, ID> (v, conversion_);
         return q;
       }
 
@@ -612,7 +628,7 @@ namespace odb
 
         query q (table_, column_);
         q += "!=";
-        q.append<T, ID> (r);
+        q.append<T, ID> (r, conversion_);
         return q;
       }
 
@@ -683,7 +699,7 @@ namespace odb
 
         query q (table_, column_);
         q += "<";
-        q.append<T, ID> (v);
+        q.append<T, ID> (v, conversion_);
         return q;
       }
 
@@ -703,7 +719,7 @@ namespace odb
 
         query q (table_, column_);
         q += "<";
-        q.append<T, ID> (r);
+        q.append<T, ID> (r, conversion_);
         return q;
       }
 
@@ -774,7 +790,7 @@ namespace odb
 
         query q (table_, column_);
         q += ">";
-        q.append<T, ID> (v);
+        q.append<T, ID> (v, conversion_);
         return q;
       }
 
@@ -794,7 +810,7 @@ namespace odb
 
         query q (table_, column_);
         q += ">";
-        q.append<T, ID> (r);
+        q.append<T, ID> (r, conversion_);
         return q;
       }
 
@@ -865,7 +881,7 @@ namespace odb
 
         query q (table_, column_);
         q += "<=";
-        q.append<T, ID> (v);
+        q.append<T, ID> (v, conversion_);
         return q;
       }
 
@@ -885,7 +901,7 @@ namespace odb
 
         query q (table_, column_);
         q += "<=";
-        q.append<T, ID> (r);
+        q.append<T, ID> (r, conversion_);
         return q;
       }
 
@@ -956,7 +972,7 @@ namespace odb
 
         query q (table_, column_);
         q += ">=";
-        q.append<T, ID> (v);
+        q.append<T, ID> (v, conversion_);
         return q;
       }
 
@@ -976,7 +992,7 @@ namespace odb
 
         query q (table_, column_);
         q += ">=";
-        q.append<T, ID> (r);
+        q.append<T, ID> (r, conversion_);
         return q;
       }
 
@@ -1120,6 +1136,7 @@ namespace odb
     private:
       const char* table_;
       const char* column_;
+      const char* conversion_;
 
       unsigned short prec_;
       short scale_;
@@ -1133,10 +1150,12 @@ namespace odb
 
     struct LIBODB_ORACLE_EXPORT lob_query_column
     {
-      // Note that we keep shalow copies of the table and column names.
+      // Note that we keep shallow copies of the table and column names.
+      // There is also no need for conversion expression since the only
+      // valid tests are is IS NULL/IS NOT NULL.
       //
       lob_query_column (const char* table, const char* column)
-          : table_ (table), column_ (column)
+        : table_ (table), column_ (column)
       {
       }
 
@@ -1179,7 +1198,7 @@ namespace odb
     template <typename T>
     struct query_column<T, id_blob>: lob_query_column
     {
-      query_column (const char* table, const char* column)
+      query_column (const char* table, const char* column, const char*)
           : lob_query_column (table, column)
       {
       }
@@ -1188,7 +1207,7 @@ namespace odb
     template <typename T>
     struct query_column<T, id_clob>: lob_query_column
     {
-      query_column (const char* table, const char* column)
+      query_column (const char* table, const char* column, const char*)
           : lob_query_column (table, column)
       {
       }
@@ -1197,7 +1216,7 @@ namespace odb
     template <typename T>
     struct query_column<T, id_nclob>: lob_query_column
     {
-      query_column (const char* table, const char* column)
+      query_column (const char* table, const char* column, const char*)
           : lob_query_column (table, column)
       {
       }
diff --git a/odb/oracle/query.ixx b/odb/oracle/query.ixx
index 7f13d41..2a41ae4 100644
--- a/odb/oracle/query.ixx
+++ b/odb/oracle/query.ixx
@@ -8,20 +8,22 @@ namespace odb
   {
     template <typename T, database_type_id ID>
     inline void query::
-    append (val_bind<T> v)
+    append (val_bind<T> v, const char* conv)
     {
       add (
         details::shared_ptr<query_param> (
-          new (details::shared) query_param_impl<T, ID> (v)));
+          new (details::shared) query_param_impl<T, ID> (v)),
+        conv);
     }
 
     template <typename T, database_type_id ID>
     inline void query::
-    append (ref_bind<T> r)
+    append (ref_bind<T> r, const char* conv)
     {
       add (
         details::shared_ptr<query_param> (
-          new (details::shared) query_param_impl<T, ID> (r)));
+          new (details::shared) query_param_impl<T, ID> (r)),
+        conv);
     }
   }
 }
diff --git a/odb/oracle/query.txx b/odb/oracle/query.txx
index dc89db1..47bf513 100644
--- a/odb/oracle/query.txx
+++ b/odb/oracle/query.txx
@@ -19,7 +19,8 @@ namespace odb
       //
       append (c.table (), c.column ());
       append ("=");
-      append<bool, ID> (val_bind<bool> (true, c.prec (), c.scale ()));
+      append<bool, ID> (val_bind<bool> (true, c.prec (), c.scale ()),
+                        c.conversion ());
     }
 
     // query_column
@@ -30,9 +31,9 @@ namespace odb
     {
       query q (table_, column_);
       q += "IN (";
-      q.append<T, ID> (val_bind<T> (v1, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v1, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v2, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v2, prec_, scale_), conversion_);
       q += ")";
       return q;
     }
@@ -43,11 +44,11 @@ namespace odb
     {
       query q (table_, column_);
       q += "IN (";
-      q.append<T, ID> (val_bind<T> (v1, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v1, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v2, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v2, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v3, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v3, prec_, scale_), conversion_);
       q += ")";
       return q;
     }
@@ -58,13 +59,13 @@ namespace odb
     {
       query q (table_, column_);
       q += "IN (";
-      q.append<T, ID> (val_bind<T> (v1, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v1, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v2, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v2, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v3, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v3, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v4, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v4, prec_, scale_), conversion_);
       q += ")";
       return q;
     }
@@ -75,15 +76,15 @@ namespace odb
     {
       query q (table_, column_);
       q += "IN (";
-      q.append<T, ID> (val_bind<T> (v1, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v1, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v2, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v2, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v3, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v3, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v4, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v4, prec_, scale_), conversion_);
       q += ",";
-      q.append<T, ID> (val_bind<T> (v5, prec_, scale_));
+      q.append<T, ID> (val_bind<T> (v5, prec_, scale_), conversion_);
       q += ")";
       return q;
     }
@@ -101,7 +102,7 @@ namespace odb
         if (i != begin)
           q += ",";
 
-        q.append<T, ID> (val_bind<T> (*i, prec_, scale_));
+        q.append<T, ID> (val_bind<T> (*i, prec_, scale_), conversion_);
       }
       q += ")";
       return q;
-- 
cgit v1.1