Add support for custom database type mapping

New pragma qualifier, map, and specifiers: as, to, from. New tests:
<database>/custom.

1 files changed, 48 insertions, 7 deletions

diff --git a/odb/relational/pgsql/context.hxx b/odb/relational/pgsql/context.hxx
index c572b01..e757b30 100644
--- a/odb/relational/pgsql/context.hxx
+++ b/odb/relational/pgsql/context.hxx
@@ -59,20 +59,26 @@ namespace relational
       sql_type () : type (invalid), range (false) {}
 
       core_type type;
-      bool range;
 
-      // VARBIT maximum length is 2^31 - 1 bit.
-      // String types can hold a maximum of 1GB of data.
+      // VARBIT maximum length is 2^31 - 1 bit. String types can hold a
+      // maximum of 1GB of data.
       //
+      bool range;
       unsigned int range_value;
+
+      // Conversion expressions for custom database types.
+      //
+      std::string to;
+      std::string from;
     };
 
     class context: public virtual relational::context
     {
     public:
       sql_type const&
-      parse_sql_type (string const&, semantics::data_member&);
-
+      parse_sql_type (string const&,
+                      semantics::data_member&,
+                      bool custom = true);
     public:
       struct invalid_sql_type
       {
@@ -85,10 +91,17 @@ namespace relational
         string message_;
       };
 
+      // If custom_db_types is NULL, then this function returns
+      // invalid type instead of throwing in case an unknown type
+      // is encountered.
+      //
       static sql_type
-      parse_sql_type (string const&);
+      parse_sql_type (string, custom_db_types const* = 0);
 
     protected:
+      virtual string const&
+      convert_expr (string const&, semantics::data_member&, bool);
+
       virtual bool
       grow_impl (semantics::class_&);
 
@@ -127,7 +140,35 @@ namespace relational
       {
         data (std::ostream& os): base_context::data (os) {}
 
-        typedef std::map<string, sql_type> sql_type_cache;
+        struct sql_type_cache_entry
+        {
+          sql_type_cache_entry ()
+              : custom_cached (false), straight_cached (false) {}
+
+          sql_type const&
+          cache_custom (sql_type const& t)
+          {
+            custom = t;
+            custom_cached = true;
+            return custom;
+          }
+
+          sql_type const&
+          cache_straight (sql_type const& t)
+          {
+            straight = t;
+            straight_cached = true;
+            return straight;
+          }
+
+          sql_type custom;   // With custom mapping.
+          sql_type straight; // Without custom mapping.
+
+          bool custom_cached;
+          bool straight_cached;
+        };
+
+        typedef std::map<string, sql_type_cache_entry> sql_type_cache;
         sql_type_cache sql_type_cache_;
       };
       data* data_;