added sql function and alias

src/CMakeLists.txt

@@ -17,7 +17,8 @@ set(SQL_SOURCES
   sql/key_value_generator.cpp
   sql/fk_value_extractor.cpp
   sql/table_repository.cpp
-  sql/any_type_to_visitor.cpp)
+  sql/any_type_to_visitor.cpp
+  sql/query_result.cpp)
 
 set(SQL_HEADER
   ../include/matador/sql/dialect.hpp

src/sql/any_type_to_visitor.cpp

@@ -9,7 +9,7 @@ void convert(std::string &dest, bool source)
 
 void convert(std::string &dest, const char *source)
 {
-  dest = source;
+  dest.assign(source);
 }
 
 long long to_long_long(const char *source)

src/sql/column.cpp

@@ -1,28 +1,24 @@
-#include <utility>
-
 #include "matador/sql/column.hpp"
 
+#include <utility>
+
 namespace matador::sql {
 
-const column::data_type_index column::data_type_index_ {
-  data_type_t::type_char,
-  data_type_t::type_short,
-  data_type_t::type_int,
-  data_type_t::type_long,
-  data_type_t::type_long_long,
-  data_type_t::type_unsigned_char,
-  data_type_t::type_unsigned_short,
-  data_type_t::type_unsigned_int,
-  data_type_t::type_unsigned_long,
-  data_type_t::type_unsigned_long_long,
-  data_type_t::type_float,
-  data_type_t::type_double,
-  data_type_t::type_bool,
-  data_type_t::type_char_pointer,
-  data_type_t::type_varchar,
-  data_type_t::type_text,
-  data_type_t::type_null,
-};
+column::column(sql_function_t func, std::string name)
+: name_(std::move(name))
+, type_(data_type_t::type_int)
+, attributes_(utils::null_attributes)
+, function_(func) {}
+
+column::column(const char *name, std::string alias)
+: name_(name)
+, attributes_(utils::null_attributes)
+, alias_(std::move(alias)) {}
+
+column::column(std::string name, std::string alias)
+: name_(std::move(name))
+, attributes_(utils::null_attributes)
+, alias_(std::move(alias)) {}
 
 column::column(std::string name, data_type_t type, utils::field_attributes attr)
 : name_(std::move(name))
@@ -57,6 +53,11 @@ data_type_t column::type() const
   return type_;
 }
 
+const std::string &column::alias() const
+{
+  return alias_;
+}
+
 const std::string &column::ref_table() const
 {
   return ref_table_;
@@ -67,6 +68,11 @@ const std::string &column::ref_column() const
   return ref_column_;
 }
 
+void column::alias(const std::string &as)
+{
+  alias_ = as;
+}
+
 std::string column::str() const
 {
   any_type_to_visitor<std::string> visitor;
@@ -74,9 +80,19 @@ std::string column::str() const
   return visitor.result;
 }
 
+bool column::is_function() const
+{
+  return function_ != sql_function_t::NONE;
+}
+
+sql_function_t column::function() const
+{
+  return function_;
+}
+
 column operator "" _col(const char *name, size_t len)
 {
-  return column(std::string(name, len));
+  return {std::string(name, len)};
 }
 
 column make_column( const std::string& name, data_type_t type, utils::field_attributes attr )

src/sql/connection.cpp

@@ -73,12 +73,6 @@ bool connection::exists(const std::string &table_name) const
   return connection_->exists(table_name);
 }
 
-query_result<record> connection::fetch(const std::string &sql) const
-{
-  auto rec = connection_->describe("person");
-  return {connection_->fetch(sql), [rec](){ return new record(rec); }};
-}
-
 std::pair<size_t, std::string> connection::execute(const std::string &sql) const
 {
   return {connection_->execute(sql), sql};

src/sql/dialect.cpp

@@ -1,4 +1,5 @@
 #include "matador/sql/dialect.hpp"
+#include "matador/sql/column.hpp"
 
 #include "matador/utils/string.hpp"
 
@@ -33,11 +34,15 @@ const std::string &dialect::data_type_at(data_type_t type) const
   return data_types_.at(type);
 }
 
-std::string dialect::prepare_identifier(const std::string &str) const
+std::string dialect::prepare_identifier(const column &col) const
 {
-  std::string result(str);
+  std::string result(col.name());
   escape_quotes_in_identifier(result);
-  quote_identifier(result);
+  if (!col.is_function()) {
+    quote_identifier(result);
+  } else {
+    return sql_func_map_.at(col.function()) + "(" + result + ")";
+  }
   return result;
 }
 

src/sql/query_builder.cpp

@@ -97,12 +97,12 @@ query_builder& query_builder::drop() {
   return *this;
 }
 
-query_builder& query_builder::select(std::initializer_list<std::string> column_names)
+query_builder& query_builder::select(std::initializer_list<column> columns)
 {
-  return select(std::vector<std::string>{column_names});
+  return select(std::vector<column>{columns});
 }
 
-query_builder& query_builder::select(const std::vector<std::string> &column_names)
+query_builder &query_builder::select(const std::vector<column> &columns)
 {
   initialize(command_t::SELECT, state_t::QUERY_SELECT);
 
@@ -111,15 +111,16 @@ query_builder& query_builder::select(const std::vector<std::string> &column_name
   query_.prototype.clear();
 
   std::string result;
-  if (column_names.size() < 2) {
-    for (const auto &col : column_names) {
+  if (columns.size() < 2) {
+    for (const auto &col : columns) {
       result.append(dialect_.prepare_identifier(col));
-      query_.prototype.append(column{col});
+      query_.prototype.append(col);
     }
   } else {
-    auto it = column_names.begin();
+    auto it = columns.begin();
     result.append(dialect_.prepare_identifier(*it++));
-    for (; it != column_names.end(); ++it) {
+    query_.prototype.append(column{*it});
+    for (; it != columns.end(); ++it) {
       result.append(", ");
       result.append(dialect_.prepare_identifier(*it));
       query_.prototype.append(column{*it});
@@ -444,4 +445,19 @@ std::string build_create_column(const column &col, const dialect &d, column_cont
     return result;
 }
 
+column alias(const std::string &column, const std::string &as)
+{
+  return {column, as};
+}
+
+column alias(column &&col, const std::string &as) {
+  col.alias(as);
+  return std::move(col);
+}
+
+column count(const std::string &column)
+{
+  return {sql_function_t::COUNT, column};
+}
+
 }

src/sql/query_intermediates.cpp

@@ -76,10 +76,10 @@ query_where_intermediate query_from_intermediate::where(const basic_condition &c
   return query_where_intermediate{session_, builder_.where(cond)};
 }
 
-query_select_intermediate::query_select_intermediate(session &s, std::vector<std::string> column_names)
+query_select_intermediate::query_select_intermediate(session &s, const std::vector<column>& columns)
 : query_start_intermediate(s)
 {
-  builder_.select(std::move(column_names));
+  builder_.select(columns);
 }
 
 query_from_intermediate query_select_intermediate::from(const std::string &table, const std::string &as)

src/sql/query_result.cpp

@@ -0,0 +1,11 @@
+#include "matador/sql/query_result.hpp"
+
+namespace matador::sql::detail {
+
+template<>
+record *create_prototype<record>(const record &prototype)
+{
+  return new record{prototype};
+}
+
+}

src/sql/session.cpp

@@ -20,10 +20,9 @@ query_drop_intermediate session::drop()
   return query_drop_intermediate{*this};
 }
 
-query_select_intermediate session::select(std::initializer_list<std::string> column_names)
+query_select_intermediate session::select(std::initializer_list<column> columns)
 {
-
-  return query_select_intermediate{*this, column_names};
+  return {*this, columns};
 }
 
 query_insert_intermediate session::insert()
@@ -52,7 +51,8 @@ query_result<record> session::fetch(const query &q) const
     it = prototypes_.emplace(q.table_name, c->describe(q.table_name)).first;
   }
   auto res = c->call_fetch(q.sql);
-  return query_result<record>{std::move(res), [it]() { return new record(it->second); }};
+  return query_result<record>{std::move(res), q.prototype};
+//  return query_result<record>{std::move(res), [it]() { return new record(it->second); }};
 }
 
 //query_result<record> session::fetch(const std::string &sql) const