Basic Qt profile implementation for SQL Server

4 files changed, 589 insertions, 0 deletions

diff --git a/odb/qt/basic-mssql.options b/odb/qt/basic-mssql.options
new file mode 100644
index 0000000..31536bb
--- /dev/null
+++ b/odb/qt/basic-mssql.options
@@ -0,0 +1,14 @@
+# file      : odb/qt/basic-mssql.options
+# author    : Constantin Michael <constantin@codesynthesis.com>
+# copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+# license   : GNU GPL v2; see accompanying LICENSE file
+
+--profile qt/version
+
+# Include the default mapping in prologue instead of epilogue to
+# allow the user to override the default mapping.
+#
+--odb-prologue '#include <odb/qt/basic/mssql/default-mapping.hxx>'
+
+--hxx-prologue '#include <odb/qt/basic/mssql/qstring-traits.hxx>'
+--hxx-prologue '#include <odb/qt/basic/mssql/qbyte-array-traits.hxx>'
diff --git a/odb/qt/basic/mssql/default-mapping.hxx b/odb/qt/basic/mssql/default-mapping.hxx
new file mode 100644
index 0000000..7e50a8e
--- /dev/null
+++ b/odb/qt/basic/mssql/default-mapping.hxx
@@ -0,0 +1,24 @@
+// file      : odb/qt/basic/mssql/default-mapping.hxx
+// author    : Constantin Michael <constantin@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_QT_BASIC_MSSQL_DEFAULT_MAPPING_HXX
+#define ODB_QT_BASIC_MSSQL_DEFAULT_MAPPING_HXX
+
+#include <QtCore/QString>
+#include <QtCore/QByteArray>
+
+// By default map QString to SQL Server VARCHAR(512) for non-id members
+// and to VARCHAR(256) for id members (the same as the default mapping
+// for std::string). Allow NULL values by default as QString provides
+// a null representation.
+//
+#pragma db value(QString) type("VARCHAR(512)") id_type("VARCHAR(256)") null
+
+// By default map QByteArray to SQL Server VARBINARY(max). Allow NULL
+// values by default as QByteArray provides a null representation.
+//
+#pragma db value(QByteArray) type("VARBINARY(max)") null
+
+#endif // ODB_QT_BASIC_MSSQL_DEFAULT_MAPPING_HXX
diff --git a/odb/qt/basic/mssql/qbyte-array-traits.hxx b/odb/qt/basic/mssql/qbyte-array-traits.hxx
new file mode 100644
index 0000000..70b7019
--- /dev/null
+++ b/odb/qt/basic/mssql/qbyte-array-traits.hxx
@@ -0,0 +1,177 @@
+// file      : odb/qt/basic/mssql/qbyte-array-traits.hxx
+// author    : Constantin Michael <constantin@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_QT_BASIC_MSSQL_QBYTE_ARRAY_TRAITS_HXX
+#define ODB_QT_BASIC_MSSQL_QBYTE_ARRAY_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <cstring> // std::memcpy
+#include <cstddef> // std::size_t
+#include <cassert>
+
+#include <QtCore/QByteArray>
+
+#include <odb/mssql/traits.hxx>
+
+namespace odb
+{
+  namespace mssql
+  {
+    template <>
+    struct default_value_traits<QByteArray, id_binary>
+    {
+      typedef QByteArray value_type;
+      typedef QByteArray query_type;
+      typedef char* image_type;
+
+      static void
+      set_value (QByteArray& v, const char* b, std::size_t n, bool is_null)
+      {
+        if (is_null)
+          v = QByteArray ();
+        else
+        {
+          // Note that we cannot use replace() here since a suitable
+          // overload was only added in Qt 4.7.
+          //
+          v.resize (static_cast<int> (n));
+          std::memcpy (v.data (), b, n);
+        }
+      }
+
+      static void
+      set_image (char* b,
+                 std::size_t c,
+                 std::size_t& n,
+                 bool& is_null,
+                 const QByteArray& v)
+      {
+        if (v.isNull ())
+          is_null = true;
+        else
+        {
+          is_null = false;
+          n = static_cast<std::size_t> (v.size ());
+
+          if (n > c)
+            n = c;
+
+          std::memcpy (b, v.constData (), n);
+        }
+      }
+    };
+
+    template <>
+    struct default_value_traits<QByteArray, id_long_binary>
+    {
+      typedef QByteArray value_type;
+      typedef QByteArray query_type;
+      typedef long_callback image_type;
+
+      static void
+      set_value (QByteArray& v,
+                 result_callback_type& cb,
+                 void*& context)
+      {
+        cb = &result_callback;
+        context = &v;
+      }
+
+      static void
+      set_image (param_callback_type& cb,
+                 const void*& context,
+                 bool& is_null,
+                 const QByteArray& v)
+      {
+        if (v.isNull ())
+          is_null = true;
+        else
+        {
+          is_null = false;
+          cb = &param_callback;
+          context = &v;
+        }
+      }
+
+      static void
+      param_callback (const void* context,
+                      std::size_t*,
+                      const void** buffer,
+                      std::size_t* size,
+                      chunk_type* chunk,
+                      void*,
+                      std::size_t)
+      {
+        const QByteArray& v (*static_cast<const QByteArray*> (context));
+
+        *buffer = v.constData ();
+        *size = static_cast<std::size_t> (v.size ());
+        *chunk = chunk_one;
+      }
+
+      static void
+      result_callback (void* context,
+                       std::size_t*,
+                       void** buffer,
+                       std::size_t* size,
+                       chunk_type chunk,
+                       std::size_t size_left,
+                       void*,
+                       std::size_t)
+      {
+        QByteArray& v (*static_cast<QByteArray*> (context));
+
+        switch (chunk)
+        {
+        case chunk_null:
+          {
+            v = QByteArray ();
+            break;
+          }
+        case chunk_one:
+          {
+            v.clear ();
+            break;
+          }
+        case chunk_first:
+          {
+            // The Native Client ODBC driver seems to always be able to
+            // return the total size. This makes things simple and
+            // efficient.
+            //
+            assert (size_left != 0);
+
+            v.resize (static_cast<int> (size_left));
+            *buffer = v.data ();
+            *size = size_left;
+            break;
+          }
+        case chunk_next:
+          {
+            // We should never get here.
+            //
+            assert (false);
+            break;
+          }
+        case chunk_last:
+          {
+            // Nothing to do here. The array is already of the correct size
+            // and should contain the data.
+            break;
+          }
+        }
+      }
+    };
+
+    template <>
+    struct default_type_traits<QByteArray>
+    {
+      static const database_type_id db_type_id = id_long_binary;
+    };
+  }
+}
+
+#endif // ODB_QT_BASIC_MSSQL_QBYTE_ARRAY_TRAITS_HXX
diff --git a/odb/qt/basic/mssql/qstring-traits.hxx b/odb/qt/basic/mssql/qstring-traits.hxx
new file mode 100644
index 0000000..9db8fd5
--- /dev/null
+++ b/odb/qt/basic/mssql/qstring-traits.hxx
@@ -0,0 +1,374 @@
+// file      : odb/qt/basic/mssql/qstring-traits.hxx
+// author    : Constantin Michael <constantin@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_QT_BASIC_MSSQL_QSTRING_TRAITS_HXX
+#define ODB_QT_BASIC_MSSQL_QSTRING_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <cstring> // std::memcpy
+#include <cstddef> // std::size_t
+#include <cassert>
+
+#include <QtCore/QString>
+
+#include <odb/mssql/traits.hxx>
+
+namespace odb
+{
+  namespace mssql
+  {
+    template <>
+    struct default_value_traits<QString, id_string>
+    {
+      typedef QString value_type;
+      typedef QString query_type;
+      typedef char* image_type;
+
+      static void
+      set_value (QString& v,
+                 const char* b,
+                 std::size_t n,
+                 bool is_null)
+      {
+        if (is_null)
+          v = QString ();
+        else
+          // On Windows the string data is in Windows code page. On Linux
+          // it is always UTF-8.
+          //
+#ifdef _WIN32
+          v = QString::fromLocal8Bit (b, static_cast<int> (n));
+#else
+          v = QString::fromUtf8 (b, static_cast<int> (n));
+#endif
+      }
+
+      static void
+      set_image (char* b,
+                 std::size_t c,
+                 std::size_t& n,
+                 bool& is_null,
+                 const QString& v)
+      {
+        if (v.isNull ())
+          is_null = true;
+        else
+        {
+          is_null = false;
+
+#ifdef _WIN32
+          const QByteArray& a (v.toLocal8Bit ());
+#else
+          const QByteArray& a (v.toUtf8 ());
+#endif
+          n = static_cast<std::size_t> (a.size ());
+
+          if (n > c)
+            n = c;
+
+          std::memcpy (b, a.constData (), n);
+        }
+      }
+    };
+
+    template <>
+    struct default_value_traits<QString, id_nstring>
+    {
+      typedef QString value_type;
+      typedef QString query_type;
+      typedef ucs2_char* image_type;
+
+      static void
+      set_value (QString& v,
+                 const ucs2_char* b,
+                 std::size_t n,
+                 bool is_null)
+      {
+        if (is_null)
+          v = QString ();
+        else
+        {
+          // Note that we cannot use replace() here since a suitable
+          // overload was only added in Qt 4.7.
+          //
+          v.resize (static_cast<int> (n));
+          std::memcpy (v.data (), b, n * 2);
+        }
+      }
+
+      static void
+      set_image (ucs2_char* b,
+                 std::size_t c,
+                 std::size_t& n,
+                 bool& is_null,
+                 const QString& v)
+      {
+        if (v.isNull ())
+          is_null = true;
+        else
+        {
+          is_null = false;
+          n = static_cast<std::size_t> (v.size ());
+
+          if (n > c)
+            n = c;
+
+          std::memcpy (b, v.constData (), n * 2);
+        }
+      }
+    };
+
+    template <>
+    struct default_value_traits<QString, id_long_string>
+    {
+      typedef QString value_type;
+      typedef QString query_type;
+      typedef long_callback image_type;
+
+      static void
+      set_value (QString& v,
+                 result_callback_type& cb,
+                 void*& context)
+      {
+        cb = &result_callback;
+        context = &v;
+      }
+
+      static void
+      set_image (param_callback_type& cb,
+                 const void*& context,
+                 bool& is_null,
+                 const QString& v)
+      {
+        if (v.isNull ())
+          is_null = true;
+        else
+        {
+          is_null = false;
+          cb = &param_callback;
+          context = &v;
+        }
+      }
+
+      static void
+      param_callback (const void* context,
+                      std::size_t* position,
+                      const void** buffer,
+                      std::size_t* size,
+                      chunk_type* chunk,
+                      void* tmp_buf,
+                      std::size_t tmp_capacity)
+      {
+        const QString& s (*static_cast<const QString*> (context));
+
+#ifdef _WIN32
+        const QByteArray& v (s.toLocal8Bit ());
+#else
+        const QByteArray& v (s.toUtf8 ());
+#endif
+
+        *size = static_cast<std::size_t> (v.size ());
+
+        if (*position == 0)
+        {
+          if (*size <= tmp_capacity)
+            *chunk = chunk_one;
+          else
+          {
+            *size = tmp_capacity;
+            *chunk = chunk_first;
+          }
+        }
+        else
+        {
+          *size -= *position;
+
+          if (*size <= tmp_capacity)
+            *chunk = chunk_last;
+          else
+          {
+            *size = tmp_capacity;
+            *chunk = chunk_next;
+          }
+        }
+
+        //@@ We might split a multi-byte sequence. Microsoft ODBC driver
+        //   doesn't support this.
+        //
+        std::memcpy (tmp_buf, v.constData () + *position, *size);
+        *buffer = tmp_buf;
+        *position += *size;
+      }
+
+      static void
+      result_callback (void* context,
+                       std::size_t*,
+                       void** buffer,
+                       std::size_t* size,
+                       chunk_type chunk,
+                       std::size_t,
+                       void* tmp_buf,
+                       std::size_t tmp_capacity)
+      {
+        QString& v (*static_cast<QString*> (context));
+
+        switch (chunk)
+        {
+        case chunk_null:
+          {
+            v = QString ();
+            break;
+          }
+        case chunk_one:
+          {
+            v.clear ();
+            break;
+          }
+        case chunk_first:
+          {
+            break;
+          }
+        case chunk_next:
+        case chunk_last:
+          {
+            // Append the data from the temporary buffer.
+            //
+#ifdef _WIN32
+            v += QString::fromLocal8Bit (static_cast<char*> (tmp_buf),
+                                         static_cast<int> (*size));
+#else
+            v += QString::fromUtf8 (static_cast<char*> (tmp_buf),
+                                    static_cast<int> (*size));
+#endif
+            break;
+          }
+        }
+
+        if (chunk == chunk_first || chunk == chunk_next)
+        {
+          *buffer = tmp_buf;
+          *size = tmp_capacity;
+        }
+      }
+    };
+
+    template <>
+    struct default_value_traits<QString, id_long_nstring>
+    {
+      typedef QString value_type;
+      typedef QString query_type;
+      typedef long_callback image_type;
+
+      static void
+      set_value (QString& v,
+                 result_callback_type& cb,
+                 void*& context)
+      {
+        cb = &result_callback;
+        context = &v;
+      }
+
+      static void
+      set_image (param_callback_type& cb,
+                 const void*& context,
+                 bool& is_null,
+                 const QString& v)
+      {
+        if (v.isNull ())
+          is_null = true;
+        else
+        {
+          is_null = false;
+          cb = &param_callback;
+          context = &v;
+        }
+      }
+
+      static void
+      param_callback (const void* context,
+                      std::size_t*,
+                      const void** buffer,
+                      std::size_t* size,
+                      chunk_type* chunk,
+                      void*,
+                      std::size_t)
+      {
+        const QString& v (*static_cast<const QString*> (context));
+
+        *buffer = v.constData ();
+        *size = static_cast<std::size_t> (v.size ()) * 2;
+        *chunk = chunk_one;
+      }
+
+      static void
+      result_callback (void* context,
+                       std::size_t*,
+                       void** buffer,
+                       std::size_t* size,
+                       chunk_type chunk,
+                       std::size_t size_left,
+                       void*,
+                       std::size_t)
+      {
+        QString& v (*static_cast<QString*> (context));
+
+        switch (chunk)
+        {
+        case chunk_null:
+          {
+            v = QString ();
+            break;
+          }
+        case chunk_one:
+          {
+            v.clear ();
+            break;
+          }
+        case chunk_first:
+          {
+            // The Native Client ODBC driver seems to always be able to
+            // return the total size. This makes things simple and
+            // efficient.
+            //
+            assert (size_left != 0);
+
+            size_left /= 2; // Convert to characters.
+            size_left++;    // One extra for the null terminator.
+
+            v.resize (static_cast<int> (size_left));
+            *buffer = v.data ();
+            *size = size_left * 2; // In bytes.
+            break;
+          }
+        case chunk_next:
+          {
+            // We should never get here.
+            //
+            assert (false);
+            break;
+          }
+        case chunk_last:
+          {
+            // Get rid of the null terminator.
+            //
+            v.resize (static_cast<int> (*size / 2));
+            break;
+          }
+        }
+      }
+    };
+
+    template <>
+    struct default_type_traits<QString>
+    {
+      static const database_type_id db_type_id = id_long_string;
+    };
+  }
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_QT_BASIC_MSSQL_QSTRING_TRAITS_HXX