fix(Data):

* make bool Session::isTransaction() return Poco::Optional
* move parsing to Statement
* SQLParser make build
* other fixes and improvemets #4230

Data/src/sql-parser/Makefile

@@ -36,7 +36,7 @@ GMAKE = make mode=$(mode)
 NAME := sqlparser
 PARSER_CPP = $(SRCPARSER)/bison_parser.cpp  $(SRCPARSER)/flex_lexer.cpp
 PARSER_H   = $(SRCPARSER)/bison_parser.h    $(SRCPARSER)/flex_lexer.h
-LIB_CFLAGS = -std=c++17 $(OPT_FLAG)
+LIB_CFLAGS = -std=c++17 -I$(SRCPARSER)/../../../ $(OPT_FLAG)
 
 relaxed_build ?= "off"
 ifeq ($(relaxed_build), on)
@@ -127,7 +127,7 @@ $(BM_BUILD): $(BM_ALL) $(LIB_BUILD)
 ############ Test & Example ############
 ########################################
 TEST_BUILD  = $(BIN)/tests
-TEST_CFLAGS = -std=c++1z -Wall -Werror -Isrc/ -Itest/ -L./ $(OPT_FLAG)
+TEST_CFLAGS = -std=c++1z -Wall -Werror -I$(SRCPARSER)/../../../ -Isrc/ -Itest/ -L./ $(OPT_FLAG)
 TEST_CPP    = $(shell find test/ -name '*.cpp')
 TEST_ALL    = $(shell find test/ -name '*.cpp') $(shell find test/ -name '*.h')
 EXAMPLE_SRC = $(shell find example/ -name '*.cpp') $(shell find example/ -name '*.h')

Data/src/sql-parser/src/SQLParserResult.cpp

@@ -1,16 +1,30 @@
 
 #include "SQLParserResult.h"
 #include <algorithm>
+#include <string.h>
 
 namespace hsql {
 
-SQLParserResult::SQLParserResult() : isValid_(false), errorMsg_(nullptr) 
+SQLParserResult::SQLParserResult() :
+  statements_(new std::vector<SQLStatement*>),
+  isValid_(false),
+  errorMsg_(nullptr),
+  errorLine_(-1),
+  errorColumn_(-1),
+  parameters_(new std::vector<Expr*>)
 {
-    statements_ = new std::vector<SQLStatement*>;
-    parameters_ = new std::vector<Expr*>;
 }
 
-SQLParserResult::SQLParserResult(SQLStatement* stmt) : isValid_(false), errorMsg_(nullptr) { addStatement(stmt); }
+SQLParserResult::SQLParserResult(SQLStatement* stmt) :
+  statements_(new std::vector<SQLStatement*>),
+  isValid_(false),
+  errorMsg_(nullptr),
+  errorLine_(-1),
+  errorColumn_(-1),
+  parameters_(new std::vector<Expr*>)
+{
+  addStatement(stmt);
+}
 
 // Move constructor.
 SQLParserResult::SQLParserResult(SQLParserResult&& moved) { *this = std::forward<SQLParserResult>(moved); }
@@ -18,22 +32,29 @@ SQLParserResult::SQLParserResult(SQLParserResult&& moved) { *this = std::forward
 SQLParserResult& SQLParserResult::operator=(SQLParserResult&& moved) {
   isValid_ = moved.isValid_;
   errorMsg_ = moved.errorMsg_;
-  statements_ = std::move(moved.statements_);
+  statements_ = moved.statements_;
+  parameters_ = moved.parameters_;
 
-  moved.errorMsg_ = nullptr;
-  moved.reset();
+  moved.reset(true);
   return *this;
 }
 
 SQLParserResult::~SQLParserResult() { reset(); }
 
-void SQLParserResult::addStatement(SQLStatement* stmt) { statements_->push_back(stmt); }
+void SQLParserResult::addStatement(SQLStatement* stmt) {
+  if (!statements_) statements_ = new std::vector<SQLStatement*>;
+  statements_->push_back(stmt);
+}
 
-const SQLStatement* SQLParserResult::getStatement(size_t index) const { return (*statements_)[index]; }
+const SQLStatement* SQLParserResult::getStatement(size_t index) const {
+  return statements_ ? (*statements_)[index] : nullptr;
+}
 
-SQLStatement* SQLParserResult::getMutableStatement(size_t index) { return (*statements_)[index]; }
+SQLStatement* SQLParserResult::getMutableStatement(size_t index) {
+  return statements_ ? (*statements_)[index] : nullptr;
+}
 
-size_t SQLParserResult::size() const { return statements_->size(); }
+size_t SQLParserResult::size() const { return statements_ ? statements_->size() : 0u; }
 
 bool SQLParserResult::isValid() const { return isValid_; }
 
@@ -46,42 +67,67 @@ int SQLParserResult::errorColumn() const { return errorColumn_; }
 void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; }
 
 void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) {
+  if (errorMsg_) free(errorMsg);
   errorMsg_ = errorMsg;
   errorLine_ = errorLine;
   errorColumn_ = errorColumn;
 }
 
-const std::vector<SQLStatement*>& SQLParserResult::getStatements() const { return *statements_; }
+const std::vector<SQLStatement*>& SQLParserResult::getStatements() const {
+  if (!statements_) statements_ = new std::vector<SQLStatement*>;
+  return *statements_;
+}
 
 std::vector<SQLStatement*> SQLParserResult::releaseStatements() {
-  std::vector<SQLStatement*> copy = *statements_;
-
-  statements_->clear();
-
+  std::vector<SQLStatement*> copy;
+  if (statements_)
+  {
+    copy = *statements_;
+    statements_->clear();
+  }
   return copy;
 }
 
-void SQLParserResult::reset() {
-  for (SQLStatement* statement : *statements_) {
-    delete statement;
+void SQLParserResult::reset(bool mv) {
+  if (statements_)
+  {
+    if (!mv)
+    {
+      for (SQLStatement* statement : *statements_) {
+        delete statement;
+      }
+      delete statements_;
+    }
+    statements_ = nullptr;
+  }
+
+  if (parameters_)
+  {
+    if (!mv) delete parameters_;
+    parameters_ = nullptr;
   }
-  delete statements_;
-  delete parameters_;
 
   isValid_ = false;
 
-  free(errorMsg_);
-  errorMsg_ = nullptr;
+  if (errorMsg_)
+  {
+    if (!mv) free(errorMsg_);
+    errorMsg_ = nullptr;
+  }
   errorLine_ = -1;
   errorColumn_ = -1;
 }
 
 // Does NOT take ownership.
 void SQLParserResult::addParameter(Expr* parameter) {
+  if (!parameters_) parameters_ = new std::vector<Expr*>;
   parameters_->push_back(parameter);
   std::sort(parameters_->begin(), parameters_->end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; });
 }
 
-const std::vector<Expr*>& SQLParserResult::parameters() { return *parameters_; }
+const std::vector<Expr*>& SQLParserResult::parameters() {
+  if (!parameters_) parameters_ = new std::vector<Expr*>;
+  return *parameters_;
+}
 
 }  // namespace hsql

Data/src/sql-parser/src/SQLParserResult.h

@@ -63,7 +63,7 @@ class SQLParser_API SQLParserResult {
   std::vector<SQLStatement*> releaseStatements();
 
   // Deletes all statements and other data within the result.
-  void reset();
+  void reset(bool mv = false);
 
   // Does NOT take ownership.
   void addParameter(Expr* parameter);
@@ -72,7 +72,7 @@ class SQLParser_API SQLParserResult {
 
  private:
   // List of statements within the result.
-  std::vector<SQLStatement*>* statements_;
+  mutable std::vector<SQLStatement*>* statements_;
 
   // Flag indicating the parsing was successful.
   bool isValid_;

Data/src/sql-parser/src/sqlparser_win.h

@@ -12,6 +12,12 @@
 	#else
 		#define SQLParser_API __declspec(dllimport)
 	#endif
+#else
+	#if defined (__GNUC__) && (__GNUC__ >= 4)
+		#define SQLParser_API __attribute__ ((visibility ("default")))
+	#else
+		#define SQLParser_API
+	#endif
 #endif