added sequence-specific code (create, drop and nextval)

source/orm/query/intermediates/query_create_intermediate.cpp

@@ -18,7 +18,9 @@ query_create_table_intermediate query_create_intermediate::table(const class tab
   context_->parts.push_back(std::make_unique<internal::query_create_table_part>(tab));
   return {context_};
 }
+
 query_create_sequence_intermediate query_create_intermediate::sequence(const std::string& sequence_name) {
+  context_->parts.push_back(std::make_unique<internal::query_create_sequence_part>(sequence_name));
   return {context_};
 }
 

source/orm/query/intermediates/query_drop_intermediate.cpp

@@ -5,7 +5,6 @@
 #include "matador/query/query_data.hpp"
 
 namespace matador::query {
-
 query_drop_intermediate::query_drop_intermediate() {
   context_->parts.push_back(std::make_unique<internal::query_drop_part>());
 }
@@ -15,4 +14,13 @@ executable_query query_drop_intermediate::table(const class table &tab) {
   return {context_};
 }
 
+executable_query query_drop_intermediate::sequence(const std::string& sequence_name) {
+  context_->parts.push_back(std::make_unique<internal::query_drop_sequence_part>(sequence_name));
+  return {context_};
+}
+
+executable_query query_drop_intermediate::schema(const std::string& schema_name) {
+  context_->parts.push_back(std::make_unique<internal::query_drop_schema_part>(schema_name));
+  return {context_};
+}
 }

source/orm/query/intermediates/query_select_intermediate.cpp

@@ -11,9 +11,11 @@ query_select_intermediate::query_select_intermediate(const std::vector<table_col
   context_->parts.push_back(std::make_unique<internal::query_select_part>(columns));
 }
 
-// query_from_intermediate query_select_intermediate::from(const table& tab) {
-//   return from(std::vector{tab});
-// }
+fetchable_query query_select_intermediate::nextval(const std::string& sequence_name) {
+  context_->parts.push_back(std::make_unique<internal::query_select_nextval_part>(sequence_name));
+  return {context_};
+}
+
 query_from_intermediate query_select_intermediate::from(const std::vector<table>& tables) {
   context_->parts.push_back(std::make_unique<internal::query_from_part>(tables));
   for (const auto& tab : tables) {

source/orm/query/internal/query_parts.cpp

@@ -134,6 +134,19 @@ const std::vector<table_column> &query_select_part::columns() const {
   return columns_;
 }
 
+query_select_nextval_part::query_select_nextval_part(std::string sequence_name)
+: query_part(sql::dialect_token::NextVal)
+, sequence_name_(std::move(sequence_name)){
+}
+
+const std::string& query_select_nextval_part::sequence_name() const {
+  return sequence_name_;
+}
+
+void query_select_nextval_part::accept(query_part_visitor& visitor) {
+  visitor.visit(*this);
+}
+
 query_from_part::query_from_part(std::vector<table> tables)
 : query_part(sql::dialect_token::From)
 , tables_(std::move(tables)) {
@@ -419,6 +432,18 @@ void query_create_table_constraints_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
+query_create_sequence_part::query_create_sequence_part(std::string sequence_name)
+: query_part(sql::dialect_token::Sequence)
+, sequence_name_(std::move(sequence_name)) {}
+
+const std::string& query_create_sequence_part::sequence_name() const {
+  return sequence_name_;
+}
+
+void query_create_sequence_part::accept(query_part_visitor& visitor) {
+  visitor.visit(*this);
+}
+
 query_create_schema_part::query_create_schema_part(std::string schema)
 : query_part(sql::dialect_token::Schema)
 , schema_(std::move(schema)) {
@@ -453,6 +478,19 @@ void query_drop_table_part::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
+query_drop_sequence_part::query_drop_sequence_part(std::string sequence_name)
+: query_part(sql::dialect_token::Table)
+, sequence_name_(std::move(sequence_name)) {
+}
+
+const std::string& query_drop_sequence_part::sequence_name() const {
+  return sequence_name_;
+}
+
+void query_drop_sequence_part::accept(query_part_visitor& visitor) {
+  visitor.visit(*this);
+}
+
 query_drop_schema_part::query_drop_schema_part(std::string schema_)
 : query_part(sql::dialect_token::Schema)
 , schema_(std::move(schema_)) {

source/orm/query/query_builder.cpp

@@ -94,6 +94,11 @@ void query_builder::visit(internal::query_select_part &part) {
   build_fetchable_columns(query_, part.columns(), *dialect_);
 }
 
+void query_builder::visit(internal::query_select_nextval_part& part) {
+  query_.sql += dialect_->nextval() + "('" + part.sequence_name() + "')";
+  prepare_prototype(query_.prototype, part.sequence_name());
+}
+
 void query_builder::visit(internal::query_from_part &part) {
   query_.table_name = part.tables().front().name();
   query_.sql += " " + dialect_->from() + " ";
@@ -301,6 +306,11 @@ void query_builder::visit(internal::query_create_table_constraints_part& part) {
   query_.sql += result;
 }
 
+void query_builder::visit(internal::query_create_sequence_part& part) {
+  query_.command = sql::sql_command::CreateSequence;
+  query_.sql += " " + dialect_->sequence() + " " + dialect_->prepare_identifier_string(part.sequence_name());
+}
+
 void query_builder::visit( internal::query_create_schema_part& part ) {
   query_.command = sql::sql_command::CreateSchema;
   query_.sql += " " + dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema());
@@ -341,6 +351,11 @@ void query_builder::visit(internal::query_set_part &part) {
   query_.sql += result;
 }
 
+void query_builder::visit(internal::query_drop_sequence_part& part) {
+  query_.command = sql::sql_command::DropSequence;
+  query_.sql += " " + dialect_->sequence() + " " + dialect_->prepare_identifier_string(part.sequence_name());
+}
+
 void query_builder::visit(internal::query_drop_table_part &part) {
   query_.table_name = part.table().name();
   query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);

source/orm/sql/dialect.cpp

@@ -171,6 +171,10 @@ const std::string &dialect::end_string_data() const {
   return token_at(dialect_token::EndStringData);
 }
 
+const std::string& dialect::exists() const {
+  return token_at(dialect_token::Exists);
+}
+
 const std::string &dialect::from() const {
   return token_at(dialect_token::From);
 }
@@ -235,6 +239,10 @@ const std::string &dialect::limit() const {
   return token_at(dialect_token::Limit);
 }
 
+const std::string& dialect::nextval() const {
+  return token_at(dialect_token::NextVal);
+}
+
 const std::string &dialect::not_() const {
   return token_at(dialect_token::Not);
 }
@@ -291,6 +299,10 @@ const std::string &dialect::set() const {
   return token_at(dialect_token::Set);
 }
 
+const std::string& dialect::sequence() const {
+  return token_at(dialect_token::Sequence);
+}
+
 const std::string &dialect::start_quote() const {
   return token_at(dialect_token::StartQuote);
 }