Merge remote-tracking branch 'origin/main'

# Conflicts:
#	demo/main.cpp

CMakeLists.txt

@@ -22,6 +22,10 @@ find_package(SQLite3 REQUIRED)
 find_package(PostgreSQL REQUIRED)
 find_package(MySQL REQUIRED)
 
+message(STATUS "Found ODBC config ${ODBC_CONFIG}")
+message(STATUS "Adding ODBC include directory: ${ODBC_INCLUDE_DIRS}")
+message(STATUS "Adding ODBC libs: ${ODBC_LIBRARIES}")
+
 message(STATUS "Found SQLite3 ${SQLite3_VERSION}")
 message(STATUS "Adding SQLite3 include directory: ${SQLite3_INCLUDE_DIRS}")
 message(STATUS "Adding SQLite3 libs: ${SQLite3_LIBRARIES}")

backends/tests/TypeTraitsTest.cpp

@@ -52,10 +52,8 @@ static const matador::utils::enum_mapper<Color> color_enum({
                                                            {Color::Brown,  "brown"}
                                                            });
 
-namespace matador::sql {
-
 template<>
-struct data_type_traits<Color, void>
+struct matador::sql::data_type_traits<Color, void>
 {
     inline static data_type_t builtin_type(std::size_t size)
     { return data_type_traits<std::string>::builtin_type(size); }
@@ -64,13 +62,12 @@ struct data_type_traits<Color, void>
     {
         std::string enum_string;
         reader.read_value(id, index, enum_string, 64);
-    auto enum_opt = color_enum.to_enum(enum_string);
+        if (const auto enum_opt = color_enum.to_enum(enum_string)) {
-    if (enum_opt) {
             value = enum_opt.value();
         }
     }
 
-  static any_type create_value(Color &value)
+    static any_type create_value(const Color &value)
     {
         return color_enum.to_string(value);
     }
@@ -81,9 +78,6 @@ struct data_type_traits<Color, void>
     }
 };
 
-}
-
-
 TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes with type traits", "[typetraits]")
 {
   schema.attach<location>("location");

demo/main.cpp

@@ -11,8 +11,7 @@
 #include <iostream>
 #include <string>
 
-struct author
+struct author {
-{
     unsigned long id{};
     std::string first_name;
     std::string last_name;
@@ -21,8 +20,7 @@ struct author
     bool distinguished{false};
 
     template<typename Operator>
-  void process(Operator &op)
+    void process( Operator& op ) {
-  {
         namespace field = matador::utils::access;
         field::primary_key( op, "id", id );
         field::attribute( op, "first_name", first_name, 63 );
@@ -33,16 +31,14 @@ struct author
     }
 };
 
-struct book
+struct book {
-{
     unsigned long id{};
     matador::sql::entity<author> book_author;
     std::string title;
     unsigned short published_in{};
 
     template<typename Operator>
-  void process(Operator &op)
+    void process( Operator& op ) {
-  {
         namespace field = matador::utils::access;
         field::primary_key( op, "id", id );
         field::attribute( op, "title", title, 511 );
@@ -51,11 +47,60 @@ struct book
     }
 };
 
+struct payload {
+    unsigned long id{};
+
+    template<typename Operator>
+    void process( Operator& op ) {
+        namespace field = matador::utils::access;
+        field::primary_key( op, "id", id );
+    }
+};
+
+struct job {
+    enum class job_state {
+        Pending,
+        Running,
+        Succeeded,
+        Failed,
+        Canceled
+    };
+
+    enum class job_mode {
+        Foreground,
+        Background
+    };
+
+    unsigned long id{};
+    matador::sql::entity<payload> payload;
+    std::string type;
+    std::string description;
+    job_state state;
+    job_mode mode;
+
+    template<typename Operator>
+    void process( Operator& op ) {
+        namespace field = matador::utils::access;
+        field::primary_key( op, "id", id );
+        field::belongs_to( op, "payload", payload, matador::utils::default_foreign_attributes );
+        field::attribute( op, "type", type, 511 );
+        field::attribute( op, "description", description, 511 );
+        field::attribute( op, "state", state );
+        field::attribute( op, "mode", mode );
+    }
+};
+
 QUERY_HELPER( authors, id, first_name, last_name, date_of_birth, year_of_birth, distinguished )
+
 QUERY_HELPER( books, id, author_id, title, published_in )
 
-int main()
+QUERY_HELPER( job, id, payload, type, description, state, mode )
-{
+
+QUERY_HELPER( payload, id )
+
+QUERY_HELPER( temporary_table, id );
+
+int main() {
     using namespace matador::sql;
     using namespace matador;
 
@@ -68,6 +113,7 @@ int main()
 
     connection c( dns );
     c.open();
+    s.create( c );
 
     auto create_authors_sql = c.query( s )
                                .create()
@@ -101,16 +147,12 @@ int main()
                    .from( qh::authors )
                    .fetch_all();
 
-  for (const auto &row: result) {
+    for (const auto& row: result) { std::cout << "Author " << row.at( qh::authors.first_name ) << "\n"; }
-    std::cout << "Author " << row.at(qh::authors.first_name) << "\n";
-  }
 
     auto update_authors_sql = c.query( s )
                                .update( qh::authors )
-    .set({
+                               .set( {{qh::authors.first_name, "Stephen"},
-           {qh::authors.first_name, "Stephen"},
+                                      {qh::authors.last_name, "King"}} )
-           {qh::authors.last_name,  "King"}
-         })
                                .where( qh::authors.last_name == "Crichton" )
                                .execute();
 
@@ -121,9 +163,7 @@ int main()
                     .from( qh::authors )
                     .fetch_all<author>();
 
-  for (const auto &a: authors) {
+    for (const auto& a: authors) { std::cout << "Author " << a.first_name << "\n"; }
-    std::cout << "Author " << a.first_name << "\n";
-  }
 
     c.query( s )
      .insert()
@@ -149,9 +189,7 @@ int main()
                              .offset( 2 )
                              .fetch_all();
 
-  for (const auto &r: select_books_sql) {
+    for (const auto& r: select_books_sql) { std::cout << "R: " << r.at( qh::books.title ) << ", " << r.at( qh::authors.last_name ) << "\n"; }
-    std::cout << "R: " << r.at(qh::books.title) << ", " << r.at(qh::authors.last_name) << "\n";
-  }
     // SELECT book.title, book.id, book.author_id, book.published_in, author.name
     // FROM book
     // INNER JOIN author ON book.author_id = author.id
@@ -168,5 +206,24 @@ int main()
 
     std::cout << "SQL: " << drop_authors_sql << "\n";
 
+    auto res = c.query( s )
+                .select( {qh::payload.id} )
+                .from( qh::payload )
+                .join_left( qh::job )
+                .on( qh::job.payload == qh::payload.id )
+                .where(
+                        in( qh::payload.id, c.query( s )
+                                             .select( {qh::job.state} )
+                                             .from( qh::job )
+                                             .where( qh::job.state == job::job_state::Running )
+                                ) &&
+                        in( qh::payload.id, c.query( s )
+                                             .select( {qh::temporary_table.id} )
+                                             .from( qh::temporary_table ) )
+                        )
+                .build();
+    // .fetch_value<unsigned long>();
+    std::cout << "SQL: " << res.sql << "\n";
+
     return 0;
 }

include/matador/sql/condition.hpp

@@ -1,6 +1,8 @@
 #ifndef QUERY_CONDITION_HPP
 #define QUERY_CONDITION_HPP
 
+#include "matador/sql/any_type_to_string_visitor.hpp"
+#include "matador/sql/query_result.hpp"
 #include "matador/sql/basic_condition.hpp"
 #include "matador/sql/dialect.hpp"
 #include "matador/sql/placeholder.hpp"
@@ -26,6 +28,8 @@ namespace matador::sql {
 
 /// @cond MATADOR_DEV
 
+class query_select;
+
 template<class L, class R, class Enabled = void>
 class condition;
 
@@ -43,6 +47,7 @@ public:
 template<class T>
 class condition<column, T, typename std::enable_if<
   std::is_scalar<T>::value &&
+  !std::is_enum<T>::value &&
   !std::is_same<std::string, T>::value &&
   !std::is_same<const char*, T>::value>::type> : public basic_column_condition
 {
@@ -82,10 +87,32 @@ public:
 };
 
 template<class T>
-class condition<T, column, typename std::enable_if<
+class condition<column, T, std::enable_if_t<std::is_enum_v<T>>> final : public basic_column_condition
-  std::is_scalar<T>::value &&
+{
-  !std::is_same<std::string, T>::value &&
+public:
-  !std::is_same<const char*, T>::value>::type> : public basic_column_condition
+  condition(const column &fld, basic_condition::operand_t op, T val)
+    : basic_column_condition(fld, op)
+    , value(val)
+  { }
+
+  T value;
+
+  std::string evaluate(const dialect &d, query_context &query) const override
+  {
+    auto at = data_type_traits<T>::create_value(value);
+    any_type_to_string_visitor value_to_string(d, query);
+    std::visit(value_to_string, at);
+    return "'" + value_to_string.result + "' " + operand + " " + d.prepare_identifier(field_);
+  }
+
+};
+
+
+template<class T>
+class condition<T, column, std::enable_if_t<
+  std::is_scalar_v<T> &&
+  !std::is_same_v<std::string, T> &&
+  !std::is_same_v<const char*, T>>> final : public basic_column_condition
 {
 public:
   condition(T val, basic_condition::operand_t op, const column &fld)
@@ -215,7 +242,7 @@ public:
    * @param op Operand of the condition
    * @param q The query to be evaluated to the IN arguments
    */
-  condition(column col, basic_condition::operand_t op, query_context &q);
+  condition(column col, basic_condition::operand_t op, const query_context &q);
 
   /**
    * @brief Evaluates the condition
@@ -229,7 +256,7 @@ public:
   std::string evaluate(const dialect &d, query_context &query) const override;
 
 private:
-  query_context &query_;
+  query_context query_;
 };
 
 /**
@@ -415,7 +442,8 @@ condition<column, std::initializer_list<V>> in(const column &col, std::initializ
  * @param q The query to be executes as sub select
  * @return The condition object
  */
-condition<column, query_context> in(const column &col, query_context &&q);
+condition<column, query_context> in(const column &col, const query_context &q);
+condition<column, query_context> in(const column &col, const query_select &q);
 
 /**
  * @brief Creates a between condition.

include/matador/sql/data_type_traits.hpp

@@ -59,7 +59,7 @@ template <> struct data_type_traits<nullptr_t, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, nullptr_t &/*value*/);
   static void bind_value(parameter_binder &binder, size_t index, nullptr_t &/*value*/);
   static void bind_result_value(result_parameter_binder &binder, size_t index, nullptr_t &/*value*/);
-  inline static any_type create_value(char &value) { return value; }
+  inline static any_type create_value(const char &value) { return value; }
 };
 
 template <> struct data_type_traits<char, void>
@@ -68,7 +68,7 @@ template <> struct data_type_traits<char, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, char &value);
   static void bind_value(parameter_binder &binder, size_t index, char &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, char &value);
-  inline static any_type create_value(char &value) { return value; }
+  inline static any_type create_value(const char &value) { return value; }
 };
 
 template <> struct data_type_traits<short, void>
@@ -77,7 +77,7 @@ template <> struct data_type_traits<short, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, short &value);
   static void bind_value(parameter_binder &binder, size_t index, short &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, short &value);
-  inline static any_type create_value(short &value) { return value; }
+  inline static any_type create_value(const short &value) { return value; }
 };
 
 template <> struct data_type_traits<int, void>
@@ -86,7 +86,7 @@ template <> struct data_type_traits<int, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, int &value);
   static void bind_value(parameter_binder &binder, size_t index, int &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, int &value);
-  inline static any_type create_value(int &value) { return value; }
+  inline static any_type create_value(const int &value) { return value; }
 };
 
 template <> struct data_type_traits<long, void>
@@ -95,7 +95,7 @@ template <> struct data_type_traits<long, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, long &value);
   static void bind_value(parameter_binder &binder, size_t index, long &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, long &value);
-  inline static any_type create_value(long &value) { return value; }
+  inline static any_type create_value(const long &value) { return value; }
 };
 
 template <> struct data_type_traits<long long, void>
@@ -104,7 +104,7 @@ template <> struct data_type_traits<long long, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, long long &value);
   static void bind_value(parameter_binder &binder, size_t index, long long &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, long long &value);
-  inline static any_type create_value(long long &value) { return value; }
+  inline static any_type create_value(const long long &value) { return value; }
 };
 
 template <> struct data_type_traits<unsigned char, void>
@@ -113,7 +113,7 @@ template <> struct data_type_traits<unsigned char, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, unsigned char &value);
   static void bind_value(parameter_binder &binder, size_t index, unsigned char &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, unsigned char &value);
-  inline static any_type create_value(unsigned char &value) { return value; }
+  inline static any_type create_value(const unsigned char &value) { return value; }
 };
 
 template <> struct data_type_traits<unsigned short, void>
@@ -122,7 +122,7 @@ template <> struct data_type_traits<unsigned short, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, unsigned short &value);
   static void bind_value(parameter_binder &binder, size_t index, unsigned short &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, unsigned short &value);
-  inline static any_type create_value(unsigned short &value) { return value; }
+  inline static any_type create_value(const unsigned short &value) { return value; }
 };
 
 template <> struct data_type_traits<unsigned int, void>
@@ -131,7 +131,7 @@ template <> struct data_type_traits<unsigned int, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, unsigned int &value);
   static void bind_value(parameter_binder &binder, size_t index, unsigned int &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, unsigned int &value);
-  inline static any_type create_value(unsigned int &value) { return value; }
+  inline static any_type create_value(const unsigned int &value) { return value; }
 };
 
 template <> struct data_type_traits<unsigned long, void>
@@ -140,7 +140,7 @@ template <> struct data_type_traits<unsigned long, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, unsigned long &value);
   static void bind_value(parameter_binder &binder, size_t index, unsigned long &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, unsigned long &value);
-  inline static any_type create_value(unsigned long &value) { return value; }
+  inline static any_type create_value(const unsigned long &value) { return value; }
 };
 
 template <> struct data_type_traits<unsigned long long, void>
@@ -149,7 +149,7 @@ template <> struct data_type_traits<unsigned long long, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, unsigned long long &value);
   static void bind_value(parameter_binder &binder, size_t index, unsigned long long &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, unsigned long long &value);
-  inline static any_type create_value(unsigned long long &value) { return value; }
+  inline static any_type create_value(const unsigned long long &value) { return value; }
 };
 
 template <> struct data_type_traits<bool, void>
@@ -158,7 +158,7 @@ template <> struct data_type_traits<bool, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, bool &value);
   static void bind_value(parameter_binder &binder, size_t index, bool &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, bool &value);
-  inline static any_type create_value(bool &value) { return value; }
+  inline static any_type create_value(const bool &value) { return value; }
 };
 
 template <> struct data_type_traits<float, void>
@@ -167,7 +167,7 @@ template <> struct data_type_traits<float, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, float &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, float &value);
   static void bind_value(parameter_binder &binder, size_t index, float &value);
-  inline static any_type create_value(float &value) { return value; }
+  inline static any_type create_value(const float &value) { return value; }
 };
 
 template <> struct data_type_traits<double, void>
@@ -176,7 +176,7 @@ template <> struct data_type_traits<double, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, double &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, double &value);
   static void bind_value(parameter_binder &binder, size_t index, double &value);
-  inline static any_type create_value(double &value) { return value; }
+  inline static any_type create_value(const double &value) { return value; }
 };
 
 template <> struct data_type_traits<const char*, void>
@@ -203,7 +203,7 @@ template <> struct data_type_traits<std::string, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, std::string &value, size_t size);
   static void bind_value(parameter_binder &binder, size_t index, std::string &value, size_t size = 0);
   static void bind_result_value(result_parameter_binder &binder, size_t index, std::string &value, size_t size = 0);
-  inline static any_type create_value(std::string &value) { return value; }
+  inline static any_type create_value(const std::string &value) { return value; }
 };
 
 template <> struct data_type_traits<utils::blob, void>
@@ -212,7 +212,7 @@ template <> struct data_type_traits<utils::blob, void>
   static void read_value(query_result_reader &reader, const char *id, size_t index, utils::blob &value);
   static void bind_value(parameter_binder &binder, size_t index, utils::blob &value);
   static void bind_result_value(result_parameter_binder &binder, size_t index, utils::blob &value);
-  inline static any_type create_value(utils::blob &value) { return value; }
+  inline static any_type create_value(const utils::blob &value) { return value; }
 };
 
 //template <> struct data_type_traits<matador::date>
@@ -232,7 +232,7 @@ template <> struct data_type_traits<utils::blob, void>
 //};
 
 template < typename EnumType >
-struct data_type_traits<EnumType, typename std::enable_if<std::is_enum<EnumType>::value>::type>
+struct data_type_traits<EnumType, std::enable_if_t<std::is_enum_v<EnumType>>>
 {
   inline static data_type_t builtin_type(std::size_t /*size*/) { return data_type_t::type_int; }
   static void read_value(query_result_reader &reader, const char *id, size_t index, EnumType &value)
@@ -241,13 +241,15 @@ struct data_type_traits<EnumType, typename std::enable_if<std::is_enum<EnumType>
   }
   static void bind_value(parameter_binder &binder, size_t index, EnumType &value)
   {
-    data_type_traits<int>::bind_value(binder, index, (int&)value);
+    data_type_traits<int>::bind_value(binder, index, static_cast<int&>(value));
   }
   static void bind_result_value(result_parameter_binder &binder, size_t index, EnumType &value)
   {
-    data_type_traits<int>::bind_result_value(binder, index, (int&)value);
+    data_type_traits<int>::bind_result_value(binder, index, static_cast<int&>(value));
+  }
+  static any_type create_value(const EnumType &value) {
+      return static_cast<int>(value);
   }
-  inline static any_type create_value(EnumType &value) { return (int)value; }
 };
 /// @endcond
 

include/matador/sql/entity_query_builder.hpp

@@ -136,7 +136,12 @@ public:
   void on_primary_key(const char *id, V &, typename std::enable_if<std::is_integral<V>::value && !std::is_same<bool, V>::value>::type* = 0)
   {
     push(id);
-    if (is_root_entity() && pk_.is_integer()) {
+    if (!is_root_entity()) {
+      return;
+    }
+    if (pk_.is_null()) {
+      entity_query_data_.pk_column_ = id;
+    } else if (pk_.is_integer()) {
       entity_query_data_.where_clause = make_condition(column{table_info_stack_.top().name, id, ""} == *pk_.as<V>());
       entity_query_data_.pk_column_ = id;
     }

include/matador/sql/schema.hpp

@@ -36,6 +36,8 @@ public:
 
   [[nodiscard]] std::string name() const;
 
+  void create(connection &c);
+
   template<typename Type>
   const table_info& attach(const std::string &table_name)
   {

src/sql/condition.cpp

@@ -1,5 +1,7 @@
 #include "matador/sql/condition.hpp"
 
+#include "matador/sql/query_intermediates.hpp"
+
 namespace matador::sql {
 
 condition<column, placeholder, std::enable_if<true>::type>::condition(const column &fld, basic_condition::operand_t op, const placeholder &val)
@@ -12,17 +14,33 @@ std::string condition<column, placeholder, std::enable_if<true>::type>::evaluate
   return d.prepare_identifier(field_) + " " + operand + " " + d.next_placeholder(query.bind_vars);
 }
 
-condition<column, query_context>::condition(column col, basic_condition::operand_t op, query_context &q)
+condition<column, query_context>::condition(column col, basic_condition::operand_t op, const query_context &q)
 : basic_column_condition(std::move(col), op), query_(q)
 {}
 
 std::string condition<column, query_context>::evaluate(const dialect &d, query_context &query) const
 {
   std::string result(d.prepare_identifier(field_) + " " + operand + " (");
-  result += (")");
+  result += query_.sql + (")");
   return result;
 }
 
+condition<column, query_context> in( const column& col, const query_context &q ) {
+    return {col, basic_condition::operand_t::IN_LIST, q};
+}
+
+condition<column, query_context> in( const column& col, const query_select& q ) {
+    return in(col, q.build());
+}
+
+condition<column, std::string> like( const column& col, const std::string& val ) {
+    return {col, basic_condition::operand_t::LIKE, val};
+}
+
+condition<column, query_context> equals( const column& col, query_context& q ) {
+    return {col, basic_condition::operand_t::EQUAL, q};
+}
+
 condition<column, column> operator==(const column &a, const column &b)
 {
   return {a, basic_condition::operand_t::EQUAL, b};

src/sql/connection.cpp

@@ -91,7 +91,7 @@ size_t connection::execute(const std::string &sql) const
   return connection_->execute(sql);
 }
 
-sql::query connection::query(const sql::schema &schema) const
+sql::query connection::query(const schema &schema) const
 {
   return sql::query(*const_cast<connection*>(this), schema);
 }

src/sql/dialect.cpp

@@ -51,8 +51,8 @@ std::string dialect::prepare_literal(const std::string &str) const
 
 void dialect::quote_identifier(std::string &str) const
 {
-  str.insert(0, token_at(token_t::START_QUOTE));
+  // str.insert(0, token_at(token_t::START_QUOTE));
-  str += token_at(token_t::END_QUOTE);
+  // str += token_at(token_t::END_QUOTE);
 }
 
 void dialect::escape_quotes_in_identifier(std::string &str) const

src/sql/query_compiler.cpp

@@ -54,7 +54,7 @@ void query_compiler::visit(query_select_part &select_part)
 void query_compiler::visit(query_from_part &from_part)
 {
   query_.table = from_part.table();
-  if (dialect_.default_schema_name().empty()) {
+  if (!dialect_.default_schema_name().empty()) {
     query_.sql += " " + dialect_.token_at(dialect::token_t::FROM) +
                   " " + dialect_.prepare_identifier(from_part.table().name) +
                   (from_part.table().alias.empty() ? "" : " AS " +

src/sql/schema.cpp

@@ -8,6 +8,13 @@ namespace matador::sql {
 schema::schema(std::string name)
 : name_(std::move(name)) {}
 
+void schema::create(connection &c) {
+    for (const auto &ti : repository_) {
+        // ti.second.prototype
+
+    }
+}
+
 std::string schema::name() const
 {
   return name_;