Expose new db_type for dynamic type mapping

include/soci/column-info.h

@@ -20,7 +20,9 @@ namespace soci
 struct SOCI_DECL column_info
 {
     std::string name;
+    // DEPRECATED. USE dataType INSTEAD.
     data_type type;
+    db_type dataType;
     std::size_t length; // meaningful for text columns only
     std::size_t precision;
     std::size_t scale;
@@ -35,37 +37,36 @@ struct type_conversion<column_info>
     static std::size_t get_numeric_value(const values & v,
         const std::string & field_name)
     {
-        data_type dt = v.get_properties(field_name).get_data_type();
+        db_type dt = v.get_properties(field_name).get_db_type();
         switch (dt)
         {
-        case dt_double:
+        case db_double:
             return static_cast<std::size_t>(
                 v.get<double>(field_name, 0.0));
-        case dt_int8:
+        case db_int8:
             return static_cast<std::size_t>(
                 v.get<int8_t>(field_name, 0));
-        case dt_uint8:
+        case db_uint8:
             return static_cast<std::size_t>(
                 v.get<uint8_t>(field_name, 0));
-        case dt_int16:
+        case db_int16:
             return static_cast<std::size_t>(
                 v.get<int16_t>(field_name, 0));
-        case dt_uint16:
+        case db_uint16:
             return static_cast<std::size_t>(
                 v.get<uint16_t>(field_name, 0));
-        case dt_int32:
+        case db_int32:
             return static_cast<std::size_t>(
                 v.get<int32_t>(field_name, 0));
-        case dt_uint32:
+        case db_uint32:
             return static_cast<std::size_t>(
                 v.get<uint32_t>(field_name, 0));
-        case dt_int64:
+        case db_int64:
             return static_cast<std::size_t>(
                 v.get<int64_t>(field_name, 0ll));
-        case dt_uint64:
+        case db_uint64:
             return static_cast<std::size_t>(
                 v.get<uint64_t>(field_name, 0ull));
-            break;
         default:
             return 0u;
         }
@@ -86,10 +87,12 @@ struct type_conversion<column_info>
             type_name.find("CHAR") != std::string::npos)
         {
             ci.type = dt_string;
+            ci.dataType = db_string;
         }
         else if (type_name == "integer" || type_name == "INTEGER")
         {
-            ci.type = dt_int32;
+            ci.type = dt_integer;
+            ci.dataType = db_int32;
         }
         else if (type_name.find("number") != std::string::npos ||
             type_name.find("NUMBER") != std::string::npos ||
@@ -99,10 +102,12 @@ struct type_conversion<column_info>
             if (ci.scale != 0)
             {
                 ci.type = dt_double;
+                ci.dataType = db_double;
             }
             else
             {
-                ci.type = dt_int32;
+                ci.type = dt_integer;
+                ci.dataType = db_int32;
             }
         }
         else if (type_name.find("time") != std::string::npos ||
@@ -111,23 +116,27 @@ struct type_conversion<column_info>
             type_name.find("DATE") != std::string::npos)
         {
             ci.type = dt_date;
+            ci.dataType = db_date;
         }
         else if (type_name.find("blob") != std::string::npos ||
             type_name.find("BLOB") != std::string::npos ||
             type_name.find("oid") != std::string::npos ||
             type_name.find("OID") != std::string::npos)
         {
             ci.type = dt_blob;
+            ci.dataType = db_blob;
         }
         else if (type_name.find("xml") != std::string::npos ||
             type_name.find("XML") != std::string::npos)
         {
             ci.type = dt_xml;
+            ci.dataType = db_xml;
         }
         else
         {
             // this seems to be a safe default
             ci.type = dt_string;
+            ci.dataType = db_string;
         }
 
         const std::string & nullable_s = v.get<std::string>("IS_NULLABLE");

include/soci/db2/soci-db2.h

@@ -197,7 +197,7 @@ struct SOCI_DB2_DECL db2_statement_backend : details::statement_backend
     std::string rewrite_for_procedure_call(std::string const& query) override;
 
     int prepare_for_describe() override;
-    void describe_column(int colNum, data_type& dtype, std::string& columnName) override;
+    void describe_column(int colNum, data_type& dtype, db_type& dbtype, std::string& columnName) override;
     size_t column_size(int col);
 
     db2_standard_into_type_backend* make_into_type_backend() override;

include/soci/empty/soci-empty.h

@@ -114,7 +114,7 @@ struct SOCI_EMPTY_DECL empty_statement_backend : details::statement_backend
     std::string rewrite_for_procedure_call(std::string const& query) override;
 
     int prepare_for_describe() override;
-    void describe_column(int colNum, data_type& dtype, std::string& columnName) override;
+    void describe_column(int colNum, data_type& dtype, db_type& dbtype, std::string& columnName) override;
 
     empty_standard_into_type_backend* make_into_type_backend() override;
     empty_standard_use_type_backend* make_use_type_backend() override;

include/soci/firebird/soci-firebird.h

@@ -202,6 +202,7 @@ struct firebird_statement_backend : details::statement_backend
 
     int prepare_for_describe() override;
     void describe_column(int colNum, data_type &dtype,
+        db_type &dbtype,
         std::string &columnName) override;
 
     firebird_standard_into_type_backend * make_into_type_backend() override;

include/soci/mysql/soci-mysql.h

@@ -182,6 +182,7 @@ struct mysql_statement_backend : details::statement_backend
 
     int prepare_for_describe() override;
     void describe_column(int colNum, data_type &dtype,
+        db_type &dbtype,
         std::string &columnName) override;
 
     mysql_standard_into_type_backend * make_into_type_backend() override;

include/soci/odbc/soci-odbc.h

@@ -254,6 +254,7 @@ struct odbc_statement_backend : details::statement_backend
 
     int prepare_for_describe() override;
     void describe_column(int colNum, data_type &dtype,
+        db_type &dbtype,
         std::string &columnName) override;
 
     // helper for defining into vector<string>

include/soci/once-temp-type.h

@@ -133,8 +133,11 @@ class SOCI_DECL ddl_type
         int precision, int scale);
     void drop_column(const std::string & tableName,
         const std::string & columnName);
+    // DEPRECATED. USE column(std::string, db_type, int, int) INSTEAD.
     ddl_type & column(const std::string & columnName, data_type dt,
         int precision = 0, int scale = 0);
+    ddl_type & column(const std::string & columnName, db_type dt,
+                      int precision = 0, int scale = 0);
     ddl_type & unique(const std::string & name,
         const std::string & columnNames);
     ddl_type & primary_key(const std::string & name,

include/soci/oracle/soci-oracle.h

@@ -230,6 +230,7 @@ struct oracle_statement_backend : details::statement_backend
 
     int prepare_for_describe() override;
     void describe_column(int colNum, data_type &dtype,
+        db_type &dbtype,
         std::string &columnName) override;
 
     // helper for defining into vector<string>
@@ -330,14 +331,86 @@ struct oracle_session_backend : details::session_backend
     }
 
     std::string create_column_type(data_type dt,
+                                   int precision, int scale) override
+    {
+        //  Oracle-specific SQL syntax:
+
+        std::string res;
+        switch (dt)
+        {
+            case dt_string:
+            {
+                std::ostringstream oss;
+
+                if (precision == 0)
+                {
+                    oss << "clob";
+                }
+                else
+                {
+                    oss << "varchar(" << precision << ")";
+                }
+
+                res += oss.str();
+            }
+                break;
+
+            case dt_date:
+                res += "timestamp";
+                break;
+
+            case dt_double:
+            {
+                std::ostringstream oss;
+                if (precision == 0)
+                {
+                    oss << "number";
+                }
+                else
+                {
+                    oss << "number(" << precision << ", " << scale << ")";
+                }
+
+                res += oss.str();
+            }
+                break;
+
+            case dt_integer:
+                res += "integer";
+                break;
+
+            case dt_long_long:
+                res += "number";
+                break;
+
+            case dt_unsigned_long_long:
+                res += "number";
+                break;
+
+            case dt_blob:
+                res += "blob";
+                break;
+
+            case dt_xml:
+                res += "xmltype";
+                break;
+
+            default:
+                throw soci_error("this data_type is not supported in create_column");
+        }
+
+        return res;
+    }
+
+    std::string create_column_type(db_type dt,
         int precision, int scale) override
     {
         //  Oracle-specific SQL syntax:
 
         std::string res;
         switch (dt)
         {
-        case dt_string:
+        case db_string:
             {
                 std::ostringstream oss;
 
@@ -354,11 +427,11 @@ struct oracle_session_backend : details::session_backend
             }
             break;
 
-        case dt_date:
+        case db_date:
             res += "timestamp";
             break;
 
-        case dt_double:
+        case db_double:
             {
                 std::ostringstream oss;
                 if (precision == 0)
@@ -374,27 +447,27 @@ struct oracle_session_backend : details::session_backend
             }
             break;
 
-        case dt_int16:
+        case db_int16:
             res += "smallint";
             break;
 
-        case dt_int32:
+        case db_int32:
             res += "integer";
             break;
 
-        case dt_int64:
+        case db_int64:
             res += "number";
             break;
 
-        case dt_uint64:
+        case db_uint64:
             res += "number";
             break;
 
-        case dt_blob:
+        case db_blob:
             res += "blob";
             break;
 
-        case dt_xml:
+        case db_xml:
             res += "xmltype";
             break;
 
@@ -407,13 +480,27 @@ struct oracle_session_backend : details::session_backend
     std::string add_column(const std::string & tableName,
         const std::string & columnName, data_type dt,
         int precision, int scale) override
+    {
+        return "alter table " + tableName + " add " +
+               columnName + " " + create_column_type(dt, precision, scale);
+    }
+    std::string add_column(const std::string & tableName,
+        const std::string & columnName, db_type dt,
+        int precision, int scale) override
     {
         return "alter table " + tableName + " add " +
             columnName + " " + create_column_type(dt, precision, scale);
     }
     std::string alter_column(const std::string & tableName,
         const std::string & columnName, data_type dt,
         int precision, int scale) override
+    {
+        return "alter table " + tableName + " modify " +
+               columnName + " " + create_column_type(dt, precision, scale);
+    }
+    std::string alter_column(const std::string & tableName,
+        const std::string & columnName, db_type dt,
+        int precision, int scale) override
     {
         return "alter table " + tableName + " modify " +
             columnName + " " + create_column_type(dt, precision, scale);

include/soci/postgresql/soci-postgresql.h

@@ -271,6 +271,7 @@ struct postgresql_statement_backend : details::statement_backend
 
     int prepare_for_describe() override;
     void describe_column(int colNum, data_type & dtype,
+        db_type & dbtype,
         std::string & columnName) override;
 
     postgresql_standard_into_type_backend * make_into_type_backend() override;

include/soci/row.h

@@ -27,14 +27,20 @@ class SOCI_DECL column_properties
 public:
 
     std::string get_name() const { return name_; }
+    // DEPRECATED. USE get_db_type() INSTEAD.
     data_type get_data_type() const { return dataType_; }
+    db_type get_db_type() const { return dbType_; }
 
     void set_name(std::string const& name) { name_ = name; }
+    // DEPRECATED. USE set_db_type(db_type) INSTEAD.
     void set_data_type(data_type dataType)  { dataType_ = dataType; }
+    void set_db_type(db_type dataType)  { dbType_ = dataType; }
 
 private:
     std::string name_;
+    // DEPRECATED. USE exchangeDataType_ INSTEAD.
     data_type dataType_;
+    db_type dbType_;
 };
 
 class SOCI_DECL row