Support for Wide Strings in SOCI for Enhanced Unicode Handling

.cirrus.yml

@@ -18,7 +18,7 @@ task:
       env:
         SOCI_CI_BACKEND: sqlite3
   freebsd_instance:
-    image_family: freebsd-13-2
+    image_family: freebsd-13-3
   install_script: ./scripts/ci/install.sh
   before_build_script: ./scripts/ci/before_build.sh
   build_script: ./scripts/ci/build.sh

docs/api/backend.md

@@ -1,6 +1,6 @@
 # Backends reference
 
-This part of the documentation is provided for those who want towrite (and contribute!) their
+This part of the documentation is provided for those who want to write (and contribute!) their
 own backends. It is anyway recommendedthat authors of new backend see the code of some existing
 backend forhints on how things are really done.
 
@@ -28,6 +28,7 @@ enum data_type
 enum db_type
 {
     db_string,
+    db_wstring,
     db_int8,
     db_uint8,
     db_int16,
@@ -50,6 +51,7 @@ enum exchange_type
 {
     x_char,
     x_stdstring,
+    x_stdwstring,
     x_int8,
     x_uint8,
     x_int16,

docs/api/client.md

@@ -13,7 +13,7 @@ The following types are commonly used in the rest of the interface:
 
 ```cpp
 // data types, as seen by the user
-enum db_type { db_string, db_date, db_double, db_int8, db_uint8, db_int16, db_uint16, db_int32, db_uint32, db_int64, db_uint64 };
+enum db_type { db_string, db_wstring, db_date, db_double, db_int8, db_uint8, db_int16, db_uint16, db_int32, db_uint32, db_int64, db_uint64 };
 
 // deprecated data types enum which may be still used but is less precise than db_type
 enum data_type { dt_string, dt_date, dt_double, dt_integer, dt_long_long, dt_unsigned_long_long };

docs/backends/odbc.md

@@ -75,6 +75,7 @@ For the ODBC backend, this type mapping is:
 | SQL_INTEGER                                               | db_int32                   | int32_t                       |
 | SQL_BIGINT                                                | db_int64                   | int64_t                       |
 | SQL_CHAR, SQL_VARCHAR                                     | db_string                  | std::string                   |
+| SQL_WCHAR, SQL_WVARCHAR, SQL_WLONGVARCHAR                 | db_wstring                 | std::wstring                  |
 | SQL_TYPE_DATE, SQL_TYPE_TIME, SQL_TYPE_TIMESTAMP          | db_date                    | std::tm                       |
 
 Not all ODBC drivers support all datatypes.

include/private/soci-exchange-cast.h

@@ -30,12 +30,24 @@ struct exchange_type_traits<x_char>
   typedef char value_type;
 };
 
+template <>
+struct exchange_type_traits<x_wchar>
+{
+  typedef wchar_t value_type;
+};
+
 template <>
 struct exchange_type_traits<x_stdstring>
 {
   typedef std::string value_type;
 };
 
+template <>
+struct exchange_type_traits<x_stdwstring>
+{
+  typedef std::wstring value_type;
+};
+
 template <>
 struct exchange_type_traits<x_int8>
 {

include/private/soci-vector-helpers.h

@@ -31,8 +31,12 @@ inline std::size_t get_vector_size(exchange_type e, void *data)
     {
         case x_char:
             return exchange_vector_type_cast<x_char>(data).size();
+        case x_wchar:
+            return exchange_vector_type_cast<x_wchar>(data).size();
         case x_stdstring:
             return exchange_vector_type_cast<x_stdstring>(data).size();
+        case x_stdwstring:
+            return exchange_vector_type_cast<x_stdwstring>(data).size();
         case x_int8:
             return exchange_vector_type_cast<x_int8>(data).size();
         case x_uint8:
@@ -73,9 +77,15 @@ inline void resize_vector(exchange_type e, void *data, std::size_t newSize)
         case x_char:
             exchange_vector_type_cast<x_char>(data).resize(newSize);
             return;
+        case x_wchar:
+            exchange_vector_type_cast<x_wchar>(data).resize(newSize);
+            return;
         case x_stdstring:
             exchange_vector_type_cast<x_stdstring>(data).resize(newSize);
             return;
+        case x_stdwstring:
+            exchange_vector_type_cast<x_stdwstring>(data).resize(newSize);
+            return;
         case x_int8:
             exchange_vector_type_cast<x_int8>(data).resize(newSize);
             return;
@@ -131,7 +141,9 @@ inline std::string& vector_string_value(exchange_type e, void *data, std::size_t
             return exchange_vector_type_cast<x_xmltype>(data).at(ind).value;
         case x_longstring:
             return exchange_vector_type_cast<x_longstring>(data).at(ind).value;
+        case x_stdwstring:
         case x_char:
+        case x_wchar:
         case x_int8:
         case x_uint8:
         case x_int16:

include/soci/exchange-traits.h

@@ -146,13 +146,27 @@ struct exchange_traits<char>
     enum { x_type = x_char };
 };
 
+template <>
+struct exchange_traits<wchar_t>
+{
+    typedef basic_type_tag type_family;
+    enum { x_type = x_wchar };
+};
+
 template <>
 struct exchange_traits<std::string>
 {
     typedef basic_type_tag type_family;
     enum { x_type = x_stdstring };
 };
 
+template <>
+struct exchange_traits<std::wstring>
+{
+    typedef basic_type_tag type_family;
+    enum { x_type = x_stdwstring };
+};
+
 template <>
 struct exchange_traits<std::tm>
 {

include/soci/odbc/soci-odbc.h

@@ -43,6 +43,16 @@ namespace details
     {
       return reinterpret_cast<SQLCHAR*>(const_cast<char*>(s.c_str()));
     }
+
+    inline SQLWCHAR* sqlchar_cast(std::wstring const& s)
+    {
+      return reinterpret_cast<SQLWCHAR*>(const_cast<wchar_t*>(s.c_str()));
+    }
+
+    inline SQLWCHAR* sqlchar_cast(std::u16string const& s)
+    {
+      return reinterpret_cast<SQLWCHAR*>(const_cast<char16_t*>(s.c_str()));
+    }
 }
 
 // Option allowing to specify the "driver completion" parameter of
@@ -187,11 +197,18 @@ struct odbc_standard_use_type_backend : details::standard_use_type_backend,
 private:
     // Copy string data to buf_ and set size, sqlType and cType to the values
     // appropriate for strings.
+
     void copy_from_string(std::string const& s,
                           SQLLEN& size,
                           SQLSMALLINT& sqlType,
                           SQLSMALLINT& cType);
 
+    void copy_from_string(
+                          const std::wstring& s,
+                          SQLLEN& size,
+                          SQLSMALLINT& sqlType,
+                          SQLSMALLINT& cType);
+
 };
 
 struct odbc_vector_use_type_backend : details::vector_use_type_backend,

include/soci/ref-counted-statement.h

@@ -11,6 +11,7 @@
 #include "soci/statement.h"
 #include "soci/into-type.h"
 #include "soci/use-type.h"
+#include "soci-unicode.h"
 // std
 #include <sstream>
 
@@ -56,6 +57,7 @@ class SOCI_DECL ref_counted_statement_base
 
     template <typename T>
     void accumulate(T const & t) { get_query_stream() << t; }
+    inline void accumulate(std::wstring const & t) { get_query_stream() << wide_to_utf8(t); }
 
     void set_tail(const std::string & tail) { tail_ = tail; }
     void set_need_comma(bool need_comma) { need_comma_ = need_comma; }

include/soci/soci-backend.h

@@ -26,6 +26,7 @@ namespace soci
 enum db_type
 {
     db_string,
+    db_wstring,
     db_int8,
     db_uint8,
     db_int16,
@@ -60,7 +61,9 @@ namespace details
 enum exchange_type
 {
     x_char,
+    x_wchar,
     x_stdstring,
+    x_stdwstring,
     x_int8,
     x_uint8,
     x_int16,
@@ -92,6 +95,10 @@ enum statement_type
     st_repeatable_query
 };
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4702)
+#endif
 // (lossless) conversion from the legacy data type enum
 inline db_type to_db_type(data_type dt)
 {
@@ -105,11 +112,16 @@ inline db_type to_db_type(data_type dt)
         case dt_unsigned_long_long: return db_uint64;
         case dt_blob:               return db_blob;
         case dt_xml:                return db_xml;
+        default:
+            throw soci_error("unsupported data_type");
     }
 
     // unreachable
     return db_string;
 }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
 // polymorphic into type backend
 
@@ -251,31 +263,40 @@ class statement_backend
         db_type& dbtype,
         std::string& column_name) = 0;
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4702)
+#endif
     // Function converting db_type to legacy data_type: this is mostly, but not
     // quite, backend-independent because different backends handled the same
     // type differently before db_type introduction.
     virtual data_type to_data_type(db_type dbt) const
     {
         switch (dbt)
         {
-            case db_string: return dt_string;
-            case db_date:   return dt_date;
-            case db_double: return dt_double;
+            case db_string:  return dt_string;
+            case db_date:    return dt_date;
+            case db_double:  return dt_double;
             case db_int8:
             case db_uint8:
             case db_int16:
             case db_uint16:
-            case db_int32:  return dt_integer;
+            case db_int32:   return dt_integer;
             case db_uint32:
-            case db_int64:  return dt_long_long;
-            case db_uint64: return dt_unsigned_long_long;
-            case db_blob:   return dt_blob;
-            case db_xml:    return dt_xml;
+            case db_int64:   return dt_long_long;
+            case db_uint64:  return dt_unsigned_long_long;
+            case db_blob:    return dt_blob;
+            case db_xml:     return dt_xml;
+            default:
+                throw soci_error("unable to convert value to data_type");
         }
 
         // unreachable
         return dt_string;
     }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
     virtual standard_into_type_backend* make_into_type_backend() = 0;
     virtual standard_use_type_backend* make_use_type_backend() = 0;