Renamed WsjcppSqlBuilderType to WsjcppSqlQueryType, redesign WsjcppSqlQuery, preparing Insert

Author: sea5kg

src/wsjcpp_sql_builder.cpp

@@ -63,15 +63,23 @@ std::string WsjcppSqlBuilderHelpers::escapingStringValue(const std::string &sVal
 }
 
 
-WsjcppSqlQuery::WsjcppSqlQuery(WsjcppSqlBuilderType sqlType, const std::string &tableName)
-  : m_sqlType(sqlType), m_tableName(tableName) {
+WsjcppSqlQuery::WsjcppSqlQuery(WsjcppSqlQueryType sqlType, WsjcppSqlBuilder *builder, const std::string &tableName)
+  : m_sqlType(sqlType), m_builder(builder), m_tableName(tableName) {
 
 }
 
-WsjcppSqlBuilderType WsjcppSqlQuery::sqlType() {
+WsjcppSqlQueryType WsjcppSqlQuery::sqlType() {
   return m_sqlType;
 }
 
+WsjcppSqlBuilder &WsjcppSqlQuery::builder() {
+  return *m_builder;
+}
+
+WsjcppSqlBuilder *WsjcppSqlQuery::builderRawPtr() {
+  return m_builder;
+}
+
 const std::string &WsjcppSqlQuery::tableName() {
   return m_tableName;
 }
@@ -175,19 +183,17 @@ std::string WsjcppSqlWhereCondition::sql() {
 }
 
 // ---------------------------------------------------------------------
-// WsjcppSqlBuilderUpdate
+// WsjcppSqlSelect
 
 WsjcppSqlSelect::WsjcppSqlSelect(const std::string &tableName, WsjcppSqlBuilder *builder)
-: WsjcppSqlQuery(WsjcppSqlBuilderType::SELECT, tableName) {
+: WsjcppSqlQuery(WsjcppSqlQueryType::SELECT, builder, tableName) {
   // TODO multitype table names with AS
-  m_tableName = tableName;
-  m_builder = builder;
 }
 
 WsjcppSqlSelect &WsjcppSqlSelect::colum(const std::string &col, const std::string &col_as) {
   auto it = std::find(m_columns.begin(), m_columns.end(), col);
   if (it != m_columns.end()) {
-    m_builder->addError("Column '" + col + "' already added to select");
+    builder().addError("Column '" + col + "' already added to select");
   } else {
     m_columns.push_back(col);
     m_columns_as[col] = col_as;
@@ -197,16 +203,12 @@ WsjcppSqlSelect &WsjcppSqlSelect::colum(const std::string &col, const std::strin
 
 WsjcppSqlWhere<WsjcppSqlSelect> &WsjcppSqlSelect::where() {
   if (!m_where) {
-    m_where = std::make_shared<WsjcppSqlWhere<WsjcppSqlSelect>>(nullptr, m_builder, this);
+    m_where = std::make_shared<WsjcppSqlWhere<WsjcppSqlSelect>>(nullptr, builderRawPtr(), this);
   }
 
   return *(m_where.get());
 }
 
-WsjcppSqlBuilder &WsjcppSqlSelect::compile() {
-  return *m_builder;
-}
-
 std::string WsjcppSqlSelect::sql() {
   std::string ret = "SELECT ";
   // TODO TOP OR LIMIT for different databases
@@ -226,45 +228,59 @@ std::string WsjcppSqlSelect::sql() {
       first = false;
     }
     ret += " FROM ";
-    ret += m_tableName;
+    ret += tableName();
   }
 
   if (m_where) {
     ret += " WHERE " + m_where->sql();
   }
 
-  // TODO where
   // TODO group by
   // TODO order by
   return ret;
 }
 
+// ---------------------------------------------------------------------
+// WsjcppSqlInsert
+
+WsjcppSqlInsert::WsjcppSqlInsert(const std::string &tableName, WsjcppSqlBuilder *builder)
+: WsjcppSqlQuery(WsjcppSqlQueryType::INSERT, builder, tableName) {
+
+}
+
+
+std::string WsjcppSqlInsert::sql() {
+  std::string ret = "INSERT INTO " + tableName();
+
+  return ret;
+};
+
 // ---------------------------------------------------------------------
 // WsjcppSqlBuilder
 
 WsjcppSqlSelect &WsjcppSqlBuilder::selectFrom(const std::string &tableName) {
   m_tableName = tableName;
-  m_nSqlType = WsjcppSqlBuilderType::SELECT;
+  m_nSqlType = WsjcppSqlQueryType::SELECT;
   m_queries.push_back(std::make_shared<WsjcppSqlSelect>(m_tableName, this));
   // TODO check must be select last one;
   return *(WsjcppSqlSelect *)(m_queries[m_queries.size() -1].get());
 }
 
 WsjcppSqlBuilder &WsjcppSqlBuilder::insertInto(const std::string &tableName) {
   m_tableName = tableName;
-  m_nSqlType = WsjcppSqlBuilderType::INSERT;
+  m_nSqlType = WsjcppSqlQueryType::INSERT;
   return *this;
 }
 
 // WsjcppSqlBuilder &WsjcppSqlBuilder::makeUpdate(const std::string &tableName) {
 //   m_tableName = tableName;
-//   m_nSqlType = WsjcppSqlBuilderType::UPDATE;
+//   m_nSqlType = WsjcppSqlQueryType::UPDATE;
 //   return *this;
 // }
 
 // WsjcppSqlBuilder &WsjcppSqlBuilder::makeDelete(const std::string &tableName) {
 //   m_tableName = tableName;
-//   m_nSqlType = WsjcppSqlBuilderType::DELETE;
+//   m_nSqlType = WsjcppSqlQueryType::DELETE;
 //   return *this;
 // }
 

src/wsjcpp_sql_builder.h

@@ -37,22 +37,25 @@ class WsjcppSqlBuilderHelpers {
   static std::string escapingStringValue(const std::string &sValue);
 };
 
-enum class WsjcppSqlBuilderType { SELECT, INSERT, UPDATE, DELETE };
+enum class WsjcppSqlQueryType { SELECT, INSERT, UPDATE, DELETE };
+
+class WsjcppSqlBuilder;
 
 class WsjcppSqlQuery {
 public:
-  WsjcppSqlQuery(WsjcppSqlBuilderType sqlType, const std::string &tableName);
-  WsjcppSqlBuilderType sqlType();
+  WsjcppSqlQuery(WsjcppSqlQueryType sqlType, WsjcppSqlBuilder *builder, const std::string &tableName);
+  WsjcppSqlQueryType sqlType();
+  WsjcppSqlBuilder &builder();
+  WsjcppSqlBuilder *builderRawPtr();
   const std::string &tableName();
   virtual std::string sql() = 0;
 
 private:
-  WsjcppSqlBuilderType m_sqlType;
+  WsjcppSqlQueryType m_sqlType;
   std::string m_tableName;
+  WsjcppSqlBuilder *m_builder;
 };
 
-class WsjcppSqlBuilder;
-
 enum class WsjcppSqlWhereType { LOGICAL_OPERATOR, CONDITION, SUB_CONDITION };
 
 class WsjcppSqlWhereBase {
@@ -224,45 +227,36 @@ class WsjcppSqlSelect : public WsjcppSqlQuery {
   WsjcppSqlWhere<WsjcppSqlSelect> &where();
   // TODO group by
   // TODO order by
-  WsjcppSqlBuilder &compile();
   virtual std::string sql() override;
 
 private:
-  std::string m_tableName;
-  WsjcppSqlBuilder *m_builder;
   std::shared_ptr<WsjcppSqlWhere<WsjcppSqlSelect>> m_where;
   std::vector<std::string> m_columns;
   std::map<std::string, std::string> m_columns_as;
 };
 
 
-// class WsjcppSqlInsert : public WsjcppSqlQuery {
-// public:
-//   WsjcppSqlInsert(const std::string &tableName, WsjcppSqlBuilder *builder);
-//   WsjcppSqlInsert &colum(const std::string &col, const std::string &col_as = "");
+class WsjcppSqlInsert : public WsjcppSqlQuery {
+public:
+  WsjcppSqlInsert(const std::string &tableName, WsjcppSqlBuilder *builder);
+  // WsjcppSqlInsert &colum(const std::string &col);
 
-//   WsjcppSqlWhere<WsjcppSqlInsert> &where();
-//   // TODO group by
-//   // TODO order by
-//   WsjcppSqlBuilder &compile();
-//   virtual std::string sql() override;
+  WsjcppSqlBuilder &builder();
+  virtual std::string sql() override;
 
-// private:
-//   std::string m_tableName;
-//   WsjcppSqlBuilder *m_builder;
-//   std::shared_ptr<WsjcppSqlWhere<WsjcppSqlSelect>> m_where;
-//   std::vector<std::string> m_columns;
-//   std::map<std::string, std::string> m_columns_as;
-// };
+private:
+  std::vector<std::string> m_columns;
+  std::map<std::string, std::string> m_columns_as;
+};
 
 class WsjcppSqlBuilder {
 public:
   // TODO begin / end transaction can be added here
 
   WsjcppSqlSelect &selectFrom(const std::string &tableName);
   WsjcppSqlBuilder &insertInto(const std::string &tableName);
-  // WsjcppSqlBuilder &makeUpdate(const std::string &sSqlTable);
-  // WsjcppSqlBuilder &makeDelete(const std::string &sSqlTable);
+  // WsjcppSqlBuilder &update(const std::string &sSqlTable);
+  // WsjcppSqlBuilder &deleteFrom(const std::string &sSqlTable);
 
   bool hasErrors();
   std::string sql();
@@ -276,6 +270,6 @@ class WsjcppSqlBuilder {
 private:
   std::vector<std::string> m_errors;
   std::string m_tableName;
-  WsjcppSqlBuilderType m_nSqlType;
+  WsjcppSqlQueryType m_nSqlType;
   std::vector<std::shared_ptr<WsjcppSqlQuery>> m_queries;
 };