cadcorp: Improve mapping of SQL integer types to C corresponding types

Porting nanodbc#370

Fine-grained mapping of SQL integer types to C corresponding types
Add reading of missing C data types for integers
Distinguish SQL_C_BIT data type for reading
Prefer mapping of SQL_C_* types to fixed-width integer types
Ensure SQL_C_SHORT and SQL_C_LONG are mapped to fixed-width variant types
test: Catch up with improved integer types mapping
Refine reading of SQL_C_TINYINT into int8_t instead of int16_t
The int16_t may lead to numeric garbage for values at range boundaries.
tests: Refine SQLite tests for integer types
Fix size of output value read for SQL_C_BIT data

Author: mloskot

nanodbc/nanodbc.cpp

@@ -614,6 +614,14 @@ struct sql_ctype
 {
 };
 
+template <typename T>
+struct sql_ctype<
+    T,
+    typename std::enable_if<is_integral8<T>::value && std::is_signed<T>::value>::type>
+{
+    static const SQLSMALLINT value = SQL_C_STINYINT;
+};
+
 template <>
 struct sql_ctype<uint8_t>
 {
@@ -3814,9 +3822,21 @@ class result::result_impl
             switch (col.sqltype_)
             {
             case SQL_BIT:
+                col.ctype_ = SQL_C_BIT;
+                col.clen_ = sizeof(int8_t);
+                break;
             case SQL_TINYINT:
+                col.ctype_ = SQL_C_STINYINT;
+                col.clen_ = sizeof(int8_t);
+                break;
             case SQL_SMALLINT:
-            case SQL_INTEGER:
+                col.ctype_ = SQL_C_SSHORT;
+                col.clen_ = sizeof(int16_t);
+                break;
+            case SQL_INTEGER: // TODO: Can be 32 or 64 bit? Then sizeof(SQLINTEGER)
+                col.ctype_ = SQL_C_SLONG;
+                col.clen_ = sizeof(int32_t);
+                break;
             case SQL_BIGINT:
                 col.ctype_ = SQL_C_SBIGINT;
                 col.clen_ = sizeof(int64_t);
@@ -4159,6 +4179,7 @@ inline void result::result_impl::get_ref_impl(short column, T& result) const
     }
 
     case SQL_C_LONG:
+    case SQL_C_SLONG:
     {
         std::string buffer(column_size + 1, 0); // ensure terminating null
         const int32_t data = *ensure_pdata<int32_t>(column);
@@ -4402,7 +4423,7 @@ inline void result::result_impl::get_ref_impl<_variant_t>(short column, _variant
     }
     case SQL_C_BIT:
     {
-        auto const v = *(ensure_pdata<short>(column));
+        auto const v = *(ensure_pdata<int8_t>(column));
         result = _variant_t(!!v ? VARIANT_TRUE : VARIANT_FALSE, VT_BOOL);
         break;
     }
@@ -4422,22 +4443,28 @@ inline void result::result_impl::get_ref_impl<_variant_t>(short column, _variant
     }
     case SQL_C_TINYINT:
     case SQL_C_STINYINT:
-        result = (char)*(ensure_pdata<short>(column));
+        result = (char)*(ensure_pdata<int16_t>(column));
         break;
     case SQL_C_UTINYINT:
-        result = (unsigned char)*(ensure_pdata<unsigned short>(column));
+        result = (unsigned char)*(ensure_pdata<uint16_t>(column));
         break;
     case SQL_C_SHORT:
     case SQL_C_SSHORT:
-        result = *(ensure_pdata<short>(column));
+    {
+        auto d = *(ensure_pdata<int16_t>(column));
+        result = _variant_t(d, VT_I2);
         break;
+    }
     case SQL_C_USHORT:
-        result = *(ensure_pdata<unsigned short>(column));
+        result = *(ensure_pdata<uint16_t>(column));
         break;
     case SQL_C_LONG:
     case SQL_C_SLONG:
-        result = *(ensure_pdata<int32_t>(column));
+    {
+        long d = *(ensure_pdata<int32_t>(column));
+        result = _variant_t(d, VT_I4); // avoid VT_INT
         break;
+    }
     case SQL_C_ULONG:
         result = *(ensure_pdata<uint32_t>(column));
         break;
@@ -4666,15 +4693,24 @@ void result::result_impl::get_ref_impl(short column, T& result) const
     using namespace std; // if int64_t is in std namespace (in c++11)
     switch (col.ctype_)
     {
+    case SQL_C_BIT:
+        result = (T) * (ensure_pdata<int8_t>(column));
+        return;
     case SQL_C_CHAR:
     case SQL_C_WCHAR:
         get_ref_from_string_column(column, result);
         return;
+    case SQL_C_TINYINT:
+    case SQL_C_STINYINT:
+        result = (T) * (ensure_pdata<int8_t>(column));
+        return;
+    case SQL_C_SHORT:
     case SQL_C_SSHORT:
-        result = (T) * (ensure_pdata<short>(column));
+        result = (T) * (ensure_pdata<int16_t>(column));
         return;
+    case SQL_C_UTINYINT:
     case SQL_C_USHORT:
-        result = (T) * (ensure_pdata<unsigned short>(column));
+        result = (T) * (ensure_pdata<uint16_t>(column));
         return;
     case SQL_C_LONG:
     case SQL_C_SLONG:

test/sqlite_test.cpp

@@ -296,7 +296,7 @@ TEST_CASE_METHOD(sqlite_fixture, "test_integral_boundary", "[sqlite][integral]")
     execute(
         connection,
         NANODBC_TEXT(
-            "create table test_integral_boundary(i1 integer,i2 integer,i4 integer,i8 integer);"));
+            "create table test_integral_boundary(i1 tinyint,i2 smallint,i4 integer,i8 bigint);"));
 
     auto const sql =
         NANODBC_TEXT("insert into test_integral_boundary(i1,i2,i4,i8) values (?,?,?,?);");

test/test_case_fixture.h

@@ -866,12 +866,12 @@ struct test_case_fixture : public base_test_fixture
         REQUIRE(result.column_datatype(0) == SQL_INTEGER);
         if (vendor_ == database_vendor::sqlserver)
         {
-            REQUIRE(result.column_c_datatype(0) == SQL_C_SBIGINT);
+            REQUIRE(result.column_c_datatype(0) == SQL_C_SLONG);
         }
         else if (vendor_ == database_vendor::sqlite)
         {
             REQUIRE(result.column_datatype_name(0) == NANODBC_TEXT("int"));
-            REQUIRE(result.column_c_datatype(0) == SQL_C_SBIGINT);
+            REQUIRE(result.column_c_datatype(0) == SQL_C_SLONG);
         }
         REQUIRE(result.column_size(0) == 10);
         REQUIRE(result.column_decimal_digits(0) == 0);
@@ -2140,7 +2140,7 @@ struct test_case_fixture : public base_test_fixture
         rs.next();
         {
             auto v = rs.get<_variant_t>(0);
-            REQUIRE(v.vt == VT_I8);
+            REQUIRE(v.vt == VT_I4);
             REQUIRE(static_cast<int>(v) == i);
         }
         {