1 files changed, 167 insertions, 0 deletions
diff --git a/odb/relational/common-query.cxx b/odb/relational/common-query.cxx
new file mode 100644
index 0000000..e49132f
--- /dev/null
+++ b/odb/relational/common-query.cxx
@@ -0,0 +1,167 @@
+// file      : odb/relational/common-query.cxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#include <odb/relational/common-query.hxx>
+
+using namespace std;
+
+namespace relational
+{
+  // query_alias_traits
+  //
+
+  void query_alias_traits::
+  generate_decl_body ()
+  {
+    os << "static const char table_name[];";
+  }
+
+  void query_alias_traits::
+  generate_def (semantics::data_member& m, semantics::class_& c)
+  {
+    // Come up with a table alias. Generally, we want it to be based
+    // on the column name. This is straightforward for single-column
+    // references. In case of a composite id, we will need to use the
+    // column prefix which is based on the data member name, unless
+    // overridden by the user. In the latter case the prefix can be
+    // empty, in which case we will just fall back on the member's
+    // public name.
+    //
+    string alias;
+    {
+      string n;
+
+      if (composite_wrapper (utype (*id_member (c))))
+      {
+        n = column_prefix (m, key_prefix_, default_name_);
+
+        if (n.empty ())
+          n = public_name_db (m);
+        else
+          n.resize (n.size () - 1); // Remove trailing underscore.
+      }
+      else
+        n = column_name (m, key_prefix_, default_name_);
+
+      alias = compose_name (column_prefix_, n);
+    }
+
+    generate_def (public_name (m), c, alias);
+  }
+
+  void query_alias_traits::
+  generate_def (string const& tag, semantics::class_& c, string const& alias)
+  {
+    semantics::class_* poly_root (polymorphic (c));
+    bool poly_derived (poly_root != 0 && poly_root != &c);
+    semantics::class_* poly_base (poly_derived ? &polymorphic_base (c) : 0);
+
+    if (poly_derived)
+      generate_def (tag, *poly_base, alias);
+
+    os << "const char alias_traits<"
+       << "  " << class_fq_name (c) << "," << endl
+       << "  id_" << db << "," << endl
+       << "  " << scope_ << "::" << tag << "_tag>::" << endl
+       << "table_name[] = ";
+
+    if (poly_root != 0)
+      os << strlit (quote_id (alias + "_" + table_name (c).uname ()));
+    else
+      os << strlit (quote_id (alias));
+
+    os << ";"
+       << endl;
+  }
+
+  entry<query_alias_traits> query_alias_traits_;
+
+
+  // query_columns_base
+  //
+
+  entry<query_columns_base> query_columns_base_;
+
+  // query_columns
+  //
+
+  void query_columns::
+  column_ctor (string const& type, string const& name, string const& base)
+  {
+    os << name << " (";
+
+    if (multi_dynamic)
+      os << "odb::query_column< " << type << " >& qc," << endl;
+
+    os << "const char* t, const char* c, const char* conv)" << endl
+       << "  : " << base << " (" << (multi_dynamic ? "qc, " : "") <<
+      "t, c, conv)"
+       << "{"
+       << "}";
+  }
+
+  void query_columns::
+  column_ctor_args_extra (semantics::data_member&)
+  {
+  }
+
+  void query_columns::
+  column_common (semantics::data_member& m,
+                 string const& type,
+                 string const& column,
+                 string const& suffix)
+  {
+    string name (public_name (m));
+
+    if (decl_)
+    {
+      string type_id (database_type_id (m));
+
+      os << "// " << name << endl
+         << "//" << endl;
+
+      os << "typedef" << endl
+         << db << "::query_column<" << endl
+         << "  " << db << "::value_traits<" << endl
+         << "    " << type << "," << endl
+         << "    " << type_id << " >::query_type," << endl
+         << "  " << type_id << " >" << endl
+         << name << suffix << ";"
+         << endl;
+    }
+    else
+    {
+      // Note that here we don't use suffix.
+      //
+      string tmpl (ptr_ ? "pointer_query_columns" : "query_columns");
+      tmpl += "< " + fq_name_ + ", id_" + db.string () + ", A >" + scope_;
+
+      os << "template <typename A>" << endl
+         << "const typename " << tmpl << "::" << name << "_type_" << endl
+         << tmpl << "::" << endl
+         << name << " (";
+
+      // Pass common query column for registration.
+      //
+      if (multi_dynamic)
+      {
+        string tmpl (ptr_ ? "pointer_query_columns" : "query_columns");
+        tmpl += "< " + fq_name_ + ", id_common, typename A::common_traits >" +
+          scope_;
+
+        os << tmpl << "::" << name << "," << endl;
+      }
+
+      os << "A::" << "table_name, " << strlit (quote_id (column));
+
+      string const& conv (convert_to_expr (column_type (), m));
+      os << ", " << (conv.empty () ? "0" : strlit (conv));
+
+      column_ctor_args_extra (m);
+
+      os << ");"
+         << endl;
+    }
+  }
+}