From e68f09c0e8c747474745f3438496e9352a199dbd Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Wed, 21 Nov 2012 13:11:43 +0200
Subject: Add dynamic multi-database query support

---
 odb/query-dynamic.hxx | 978 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 978 insertions(+)
 create mode 100644 odb/query-dynamic.hxx

(limited to 'odb/query-dynamic.hxx')

diff --git a/odb/query-dynamic.hxx b/odb/query-dynamic.hxx
new file mode 100644
index 0000000..ed32ec9
--- /dev/null
+++ b/odb/query-dynamic.hxx
@@ -0,0 +1,978 @@
+// file      : odb/query-dynamic.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_QUERY_DYNAMIC_HXX
+#define ODB_QUERY_DYNAMIC_HXX
+
+#include <odb/pre.hxx>
+
+#include <string>
+#include <vector>
+#include <cstddef> // std::size_t
+
+#include <odb/forward.hxx>
+#include <odb/query.hxx>
+
+#include <odb/details/export.hxx>
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+  struct native_column_info;
+
+  template <typename T>
+  struct val_bind
+  {
+    explicit
+    val_bind (const T& v): val (v) {}
+
+    const T& val;
+  };
+
+  template <typename T>
+  struct ref_bind
+  {
+    explicit
+    ref_bind (const T& r): ref (r) {}
+
+    const T& ref;
+  };
+
+  //
+  //
+  struct LIBODB_EXPORT query_param: details::shared_base
+  {
+    virtual ~query_param ();
+    query_param (const void* v): value (v) {}
+
+    const void* value;
+  };
+
+  // For by-value parameters we have to make a copy since the original
+  // can be gone by the time we translate to native query.
+  //
+  template <typename T>
+  struct val_query_param: query_param
+  {
+    val_query_param (const T& v): query_param (&copy), copy (v) {}
+
+    T copy;
+  };
+
+  //
+  //
+  class LIBODB_EXPORT query_base
+  {
+  public:
+    // Internally the query clause is stored in a Reverse Polish Notation-
+    // like representation which also allows us to traverse it as a syntax
+    // tree.
+    //
+    // Let's keep this class POD so that std::vector can do more
+    // efficient copying, etc.
+    //
+    struct clause_part
+    {
+      // Note that the order of enumerators is important (used as indexes).
+      //
+      enum kind_type
+      {
+        kind_column,    // native_info points to the native_column_info array.
+
+        kind_param_val, // data points to query_param while native_info points
+        kind_param_ref, // to the native_column_info array.
+
+        kind_native,    // data is the index in the strings vector.
+
+        kind_true,      // true literal.
+        kind_false,     // false literal.
+
+        // Operators.
+        //
+        // For binary operators, data is the index of the last element
+        // belonging to the left hand side sub-expression.
+        //
+        op_add,         // +  (concatenation of two sub-expressions)
+
+        op_and,         // &&
+        op_or,          // ||
+        op_not,         // !
+
+        op_null,        // is_null ()
+        op_not_null,    // is_not_null ()
+
+        op_in,          // in(), data is the number of arguments
+
+        op_eq,          // ==
+        op_ne,          // !=
+        op_lt,          // <
+        op_gt,          // >
+        op_le,          // <=
+        op_ge           // >=
+      };
+
+      kind_type kind;
+      std::size_t data;
+      const native_column_info* native_info;
+    };
+
+  public:
+    ~query_base ()
+    {
+      clear ();
+    }
+
+    query_base () {}
+
+    // True or false literal.
+    //
+    explicit
+    query_base (bool v)
+    {
+      append (v ? clause_part::kind_true : clause_part::kind_false, 0);
+    }
+
+    explicit
+    query_base (const char* native)
+    {
+      append (native);
+    }
+
+    explicit
+    query_base (const std::string& native)
+    {
+      append (native);
+    }
+
+    query_base (const query_column<bool>&);
+
+    query_base (const query_base& x)
+    {
+      append (x);
+    }
+
+    query_base&
+    operator= (const query_base& x)
+    {
+      if (this != &x)
+      {
+        clear ();
+        append (x);
+      }
+
+      return *this;
+    }
+
+  public:
+    template <typename T>
+    static val_bind<T>
+    _val (const T& x)
+    {
+      return val_bind<T> (x);
+    }
+
+    template <typename T>
+    static ref_bind<T>
+    _ref (const T& x)
+    {
+      return ref_bind<T> (x);
+    }
+
+  public:
+    query_base&
+    operator+= (const query_base&);
+
+    query_base&
+    operator+= (const std::string& native);
+
+  public:
+    bool
+    empty () const
+    {
+      return clause_.empty ();
+    }
+
+    bool
+    const_true () const
+    {
+      return clause_.size () == 1 &&
+        clause_.front ().kind == clause_part::kind_true;
+    }
+
+    // Implementation details.
+    //
+  public:
+    explicit
+    query_base (const native_column_info* c)
+    {
+      append (c);
+    }
+
+    // Native.
+    //
+    void
+    append (const std::string&);
+
+    // Query fragment.
+    //
+    void
+    append (const query_base&);
+
+    // Operator.
+    //
+    void
+    append (clause_part::kind_type k, std::size_t data)
+    {
+      clause_.push_back (clause_part ());
+      clause_.back ().kind = k;
+      clause_.back ().data = data;
+    }
+
+    // Column.
+    //
+    void
+    append (const native_column_info* c)
+    {
+      clause_.push_back (clause_part ());
+      clause_.back ().kind = clause_part::kind_column;
+      clause_.back ().native_info = c;
+    }
+
+    // Parameter.
+    //
+    void
+    append_ref (const void* ref, const native_column_info*);
+
+    template <typename T>
+    void
+    append_val (const T& val, const native_column_info*);
+
+    void
+    clear ();
+
+  public:
+    typedef std::vector<clause_part> clause_type;
+    typedef std::vector<std::string> strings_type;
+
+    const clause_type&
+    clause () const
+    {
+      return clause_;
+    }
+
+    const strings_type&
+    strings () const
+    {
+      return strings_;
+    }
+
+  private:
+    clause_type clause_;
+    strings_type strings_;
+  };
+
+  inline query_base
+  operator+ (const query_base& x, const query_base& y)
+  {
+    query_base r (x);
+    r += y;
+    return r;
+  }
+
+  inline query_base
+  operator+ (const query_base& q, const std::string& s)
+  {
+    query_base r (q);
+    r += s;
+    return r;
+  }
+
+  inline query_base
+  operator+ (const std::string& s, const query_base& q)
+  {
+    query_base r (s);
+    r += q;
+    return r;
+  }
+
+  LIBODB_EXPORT query_base
+  operator&& (const query_base&, const query_base&);
+
+  LIBODB_EXPORT query_base
+  operator|| (const query_base&, const query_base&);
+
+  LIBODB_EXPORT query_base
+  operator! (const query_base&);
+
+  //
+  //
+  struct native_column_info
+  {
+    const void* column;
+    void* param_factory;
+  };
+
+  template <typename T>
+  const T&
+  type_instance ();
+
+  // This class template has to remain POD since we rely on it being
+  // 0-initialized before any dynamic initialization takes place in
+  // any other translation unit.
+  //
+  template <typename T>
+  struct query_column
+  {
+    // Array of pointers to database-specific columns. It will be
+    // automatically zero-initialized since query_column instances
+    // are always static.
+    //
+    native_column_info native_info[database_count];
+
+    // is_null, is_not_null
+    //
+  public:
+    query_base
+    is_null () const
+    {
+      query_base q (native_info);
+      q.append (query_base::clause_part::op_null, 0);
+      return q;
+    }
+
+    query_base
+    is_not_null () const
+    {
+      query_base q (native_info);
+      q.append (query_base::clause_part::op_not_null, 0);
+      return q;
+    }
+
+    // in
+    //
+  public:
+    query_base
+    in (const T&, const T&) const;
+
+    query_base
+    in (const T&, const T&, const T&) const;
+
+    query_base
+    in (const T&, const T&, const T&, const T&) const;
+
+    query_base
+    in (const T&, const T&, const T&, const T&, const T&) const;
+
+    template <typename I>
+    query_base
+    in_range (I begin, I end) const;
+
+    // ==
+    //
+  public:
+    query_base
+    equal (val_bind<T> v) const
+    {
+      query_base q (native_info);
+      q.append_val (v.val, native_info);
+      q.append (query_base::clause_part::op_eq, 0);
+      return q;
+    }
+
+    query_base
+    equal (ref_bind<T> r) const
+    {
+      query_base q (native_info);
+      q.append_ref (&r.ref, native_info);
+      q.append (query_base::clause_part::op_eq, 0);
+      return q;
+    }
+
+    friend query_base
+    operator== (const query_column& c, const T& v)
+    {
+      return c.equal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator== (const T& v, const query_column& c)
+    {
+      return c.equal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator== (const query_column& c, val_bind<T> v)
+    {
+      return c.equal (v);
+    }
+
+    friend query_base
+    operator== (val_bind<T> v, const query_column& c)
+    {
+      return c.equal (v);
+    }
+
+    template <typename T2>
+    friend query_base
+    operator== (const query_column& c, val_bind<T2> v)
+    {
+      return c.equal (val_bind<T> (T (v.val)));
+    }
+
+    template <typename T2>
+    friend query_base
+    operator== (val_bind<T2> v, const query_column& c)
+    {
+      return c.equal (val_bind<T> (T (v.val)));
+    }
+
+    friend query_base
+    operator== (const query_column& c, ref_bind<T> r)
+    {
+      return c.equal (r);
+    }
+
+    friend query_base
+    operator== (ref_bind<T> r, const query_column& c)
+    {
+      return c.equal (r);
+    }
+
+    // !=
+    //
+  public:
+    query_base
+    unequal (val_bind<T> v) const
+    {
+      query_base q (native_info);
+      q.append_val (v.val, native_info);
+      q.append (query_base::clause_part::op_ne, 0);
+      return q;
+    }
+
+    query_base
+    unequal (ref_bind<T> r) const
+    {
+      query_base q (native_info);
+      q.append_ref (&r.ref, native_info);
+      q.append (query_base::clause_part::op_ne, 0);
+      return q;
+    }
+
+    friend query_base
+    operator!= (const query_column& c, const T& v)
+    {
+      return c.unequal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator!= (const T& v, const query_column& c)
+    {
+      return c.unequal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator!= (const query_column& c, val_bind<T> v)
+    {
+      return c.unequal (v);
+    }
+
+    friend query_base
+    operator!= (val_bind<T> v, const query_column& c)
+    {
+      return c.unequal (v);
+    }
+
+    template <typename T2>
+    friend query_base
+    operator!= (const query_column& c, val_bind<T2> v)
+    {
+      return c.unequal (val_bind<T> (T (v.val)));
+    }
+
+    template <typename T2>
+    friend query_base
+    operator!= (val_bind<T2> v, const query_column& c)
+    {
+      return c.unequal (val_bind<T> (T (v.val)));
+    }
+
+    friend query_base
+    operator!= (const query_column& c, ref_bind<T> r)
+    {
+      return c.unequal (r);
+    }
+
+    friend query_base
+    operator!= (ref_bind<T> r, const query_column& c)
+    {
+      return c.unequal (r);
+    }
+
+    // <
+    //
+  public:
+    query_base
+    less (val_bind<T> v) const
+    {
+      query_base q (native_info);
+      q.append_val (v.val, native_info);
+      q.append (query_base::clause_part::op_lt, 0);
+      return q;
+    }
+
+    query_base
+    less (ref_bind<T> r) const
+    {
+      query_base q (native_info);
+      q.append_ref (&r.ref, native_info);
+      q.append (query_base::clause_part::op_lt, 0);
+      return q;
+    }
+
+    friend query_base
+    operator< (const query_column& c, const T& v)
+    {
+      return c.less (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator< (const T& v, const query_column& c)
+    {
+      return c.greater (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator< (const query_column& c, val_bind<T> v)
+    {
+      return c.less (v);
+    }
+
+    friend query_base
+    operator< (val_bind<T> v, const query_column& c)
+    {
+      return c.greater (v);
+    }
+
+    template <typename T2>
+    friend query_base
+    operator< (const query_column& c, val_bind<T2> v)
+    {
+      return c.less (val_bind<T> (T (v.val)));
+    }
+
+    template <typename T2>
+    friend query_base
+    operator< (val_bind<T2> v, const query_column& c)
+    {
+      return c.greater (val_bind<T> (T (v.val)));
+    }
+
+    friend query_base
+    operator< (const query_column& c, ref_bind<T> r)
+    {
+      return c.less (r);
+    }
+
+    friend query_base
+    operator< (ref_bind<T> r, const query_column& c)
+    {
+      return c.greater (r);
+    }
+
+    // >
+    //
+  public:
+    query_base
+    greater (val_bind<T> v) const
+    {
+      query_base q (native_info);
+      q.append_val (v.val, native_info);
+      q.append (query_base::clause_part::op_gt, 0);
+      return q;
+    }
+
+    query_base
+    greater (ref_bind<T> r) const
+    {
+      query_base q (native_info);
+      q.append_ref (&r.ref, native_info);
+      q.append (query_base::clause_part::op_gt, 0);
+      return q;
+    }
+
+    friend query_base
+    operator> (const query_column& c, const T& v)
+    {
+      return c.greater (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator> (const T& v, const query_column& c)
+    {
+      return c.less (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator> (const query_column& c, val_bind<T> v)
+    {
+      return c.greater (v);
+    }
+
+    friend query_base
+    operator> (val_bind<T> v, const query_column& c)
+    {
+      return c.less (v);
+    }
+
+    template <typename T2>
+    friend query_base
+    operator> (const query_column& c, val_bind<T2> v)
+    {
+      return c.greater (val_bind<T> (T (v.val)));
+    }
+
+    template <typename T2>
+    friend query_base
+    operator> (val_bind<T2> v, const query_column& c)
+    {
+      return c.less (val_bind<T> (T (v.val)));
+    }
+
+    friend query_base
+    operator> (const query_column& c, ref_bind<T> r)
+    {
+      return c.greater (r);
+    }
+
+    friend query_base
+    operator> (ref_bind<T> r, const query_column& c)
+    {
+      return c.less (r);
+    }
+
+    // <=
+    //
+  public:
+    query_base
+    less_equal (val_bind<T> v) const
+    {
+      query_base q (native_info);
+      q.append_val (v.val, native_info);
+      q.append (query_base::clause_part::op_le, 0);
+      return q;
+    }
+
+    query_base
+    less_equal (ref_bind<T> r) const
+    {
+      query_base q (native_info);
+      q.append_ref (&r.ref, native_info);
+      q.append (query_base::clause_part::op_le, 0);
+      return q;
+    }
+
+    friend query_base
+    operator<= (const query_column& c, const T& v)
+    {
+      return c.less_equal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator<= (const T& v, const query_column& c)
+    {
+      return c.greater_equal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator<= (const query_column& c, val_bind<T> v)
+    {
+      return c.less_equal (v);
+    }
+
+    friend query_base
+    operator<= (val_bind<T> v, const query_column& c)
+    {
+      return c.greater_equal (v);
+    }
+
+    template <typename T2>
+    friend query_base
+    operator<= (const query_column& c, val_bind<T2> v)
+    {
+      return c.less_equal (val_bind<T> (T (v.val)));
+    }
+
+    template <typename T2>
+    friend query_base
+    operator<= (val_bind<T2> v, const query_column& c)
+    {
+      return c.greater_equal (val_bind<T> (T (v.val)));
+    }
+
+    friend query_base
+    operator<= (const query_column& c, ref_bind<T> r)
+    {
+      return c.less_equal (r);
+    }
+
+    friend query_base
+    operator<= (ref_bind<T> r, const query_column& c)
+    {
+      return c.greater_equal (r);
+    }
+
+    // >=
+    //
+  public:
+    query_base
+    greater_equal (val_bind<T> v) const
+    {
+      query_base q (native_info);
+      q.append_val (v.val, native_info);
+      q.append (query_base::clause_part::op_ge, 0);
+      return q;
+    }
+
+    query_base
+    greater_equal (ref_bind<T> r) const
+    {
+      query_base q (native_info);
+      q.append_ref (&r.ref, native_info);
+      q.append (query_base::clause_part::op_ge, 0);
+      return q;
+    }
+
+    friend query_base
+    operator>= (const query_column& c, const T& v)
+    {
+      return c.greater_equal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator>= (const T& v, const query_column& c)
+    {
+      return c.less_equal (val_bind<T> (v));
+    }
+
+    friend query_base
+    operator>= (const query_column& c, val_bind<T> v)
+    {
+      return c.greater_equal (v);
+    }
+
+    friend query_base
+    operator>= (val_bind<T> v, const query_column& c)
+    {
+      return c.less_equal (v);
+    }
+
+    template <typename T2>
+    friend query_base
+    operator>= (const query_column& c, val_bind<T2> v)
+    {
+      return c.greater_equal (val_bind<T> (T (v.val)));
+    }
+
+    template <typename T2>
+    friend query_base
+    operator>= (val_bind<T2> v, const query_column& c)
+    {
+      return c.less_equal (val_bind<T> (T (v.val)));
+    }
+
+    friend query_base
+    operator>= (const query_column& c, ref_bind<T> r)
+    {
+      return c.greater_equal (r);
+    }
+
+    friend query_base
+    operator>= (ref_bind<T> r, const query_column& c)
+    {
+      return c.less_equal (r);
+    }
+
+    // Column comparison.
+    //
+  public:
+    template <typename T2>
+    query_base
+    operator== (const query_column<T2>& c) const
+    {
+      // We can compare columns only if we can compare their C++ types.
+      //
+      (void) (sizeof (type_instance<T> () == type_instance<T2> ()));
+
+      query_base q (native_info);
+      q.append (c.native_info);
+      q.append (query_base::clause_part::op_eq, 0);
+      return q;
+    }
+
+    template <typename T2>
+    query_base
+    operator!= (const query_column<T2>& c) const
+    {
+      // We can compare columns only if we can compare their C++ types.
+      //
+      (void) (sizeof (type_instance<T> () != type_instance<T2> ()));
+
+      query_base q (native_info);
+      q.append (c.native_info);
+      q.append (query_base::clause_part::op_ne, 0);
+      return q;
+    }
+
+    template <typename T2>
+    query_base
+    operator< (const query_column<T2>& c) const
+    {
+      // We can compare columns only if we can compare their C++ types.
+      //
+      (void) (sizeof (type_instance<T> () < type_instance<T2> ()));
+
+      query_base q (native_info);
+      q.append (c.native_info);
+      q.append (query_base::clause_part::op_lt, 0);
+      return q;
+    }
+
+    template <typename T2>
+    query_base
+    operator> (const query_column<T2>& c) const
+    {
+      // We can compare columns only if we can compare their C++ types.
+      //
+      (void) (sizeof (type_instance<T> () > type_instance<T2> ()));
+
+      query_base q (native_info);
+      q.append (c.native_info);
+      q.append (query_base::clause_part::op_gt, 0);
+      return q;
+    }
+
+    template <typename T2>
+    query_base
+    operator<= (const query_column<T2>& c) const
+    {
+      // We can compare columns only if we can compare their C++ types.
+      //
+      (void) (sizeof (type_instance<T> () <= type_instance<T2> ()));
+
+      query_base q (native_info);
+      q.append (c.native_info);
+      q.append (query_base::clause_part::op_le, 0);
+      return q;
+    }
+
+    template <typename T2>
+    query_base
+    operator>= (const query_column<T2>& c) const
+    {
+      // We can compare columns only if we can compare their C++ types.
+      //
+      (void) (sizeof (type_instance<T> () >= type_instance<T2> ()));
+
+      query_base q (native_info);
+      q.append (c.native_info);
+      q.append (query_base::clause_part::op_ge, 0);
+      return q;
+    }
+  };
+
+  // Provide operator+() for using columns to construct native
+  // query fragments (e.g., ORDER BY).
+  //
+  template <typename T>
+  inline query_base
+  operator+ (const query_column<T>& c, const std::string& s)
+  {
+    query_base q (c.native_info);
+    q.append (s);
+    q.append (query_base::clause_part::op_add, 0);
+    return q;
+  }
+
+  template <typename T>
+  inline query_base
+  operator+ (const std::string& s, const query_column<T>& c)
+  {
+    query_base q (s);
+    q.append (c.native_info);
+    q.append (query_base::clause_part::op_add, 0);
+    return q;
+  }
+
+  template <typename T>
+  inline query_base
+  operator+ (const query_column<T>& c, const query_base& q)
+  {
+    query_base r (c.native_info);
+    r.append (q);
+    r.append (query_base::clause_part::op_add, 0);
+    return r;
+  }
+
+  template <typename T>
+  inline query_base
+  operator+ (const query_base& q, const query_column<T>& c)
+  {
+    query_base r (q);
+    r.append (c.native_info);
+    r.append (query_base::clause_part::op_add, q.clause ().size () - 1);
+    return r;
+  }
+
+  //
+  //
+  template <typename T>
+  class query<T, query_base>: public query_base,
+                              public query_selector<T, id_common>::columns_type
+  {
+  public:
+    // We don't define any typedefs here since they may clash with
+    // column names defined by our base type.
+    //
+
+    query ()
+    {
+    }
+
+    explicit
+    query (bool v)
+        : query_base (v)
+    {
+    }
+
+    explicit
+    query (const char* q)
+        : query_base (q)
+    {
+    }
+
+    explicit
+    query (const std::string& q)
+        : query_base (q)
+    {
+    }
+
+    query (const query_base& q)
+        : query_base (q)
+    {
+    }
+
+    query (const query_column<bool>& qc)
+        : query_base (qc)
+    {
+    }
+  };
+}
+
+#include <odb/query-dynamic.ixx>
+#include <odb/query-dynamic.txx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_QUERY_DYNAMIC_HXX
-- 
cgit v1.1