5370 sync upstream sql parser

.github/path-filters.yml

@@ -31,3 +31,6 @@ data:
   - 'Data/**'
   - 'Redis/**'
   - 'MongoDB/**'
+
+sqlparser:
+  - 'Data/SQLParser/**'

.github/workflows/ci.yml

@@ -99,6 +99,7 @@ jobs:
       foundation_util: ${{ steps.filter.outputs.foundation_util }}
       arm_cross: ${{ steps.filter.outputs.arm_cross }}
       data: ${{ steps.filter.outputs.data }}
+      sqlparser: ${{ steps.filter.outputs.sqlparser }}
     steps:
       - uses: actions/checkout@v5
       - uses: dorny/paths-filter@v4
@@ -1238,6 +1239,26 @@ jobs:
           retry_on: any
           command: nix-shell Data/ODBC/oracle.nix --pure --run "build_and_test"
 
+  # Standalone hyrise/sql-parser upstream tests: builds the vendored
+  # SQLParser sources with its own Makefile and runs the upstream test
+  # suite (queries-good.sql / queries-bad.sql), a valgrind leak check,
+  # and the bison grammar-conflict check. This is the only job that
+  # exercises the grammar-level features (FOREIGN KEY, NULLS FIRST/LAST,
+  # CSV import options, schema-qualified functions, ...). bison and flex
+  # are pre-installed on ubuntu-24.04 (3.8.2 and 2.6.4); valgrind is too.
+  linux-sqlparser-upstream-tests:
+    runs-on: ubuntu-24.04
+    needs: changes
+    if: |
+      needs.changes.outputs.sqlparser == 'true' ||
+      needs.changes.outputs.ci_core == 'true' ||
+      github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+    steps:
+      - uses: actions/checkout@v5
+      - run: sudo apt -y update && sudo apt -y install bison flex valgrind
+      - run: cd Data/SQLParser && make -j$(nproc)
+      - run: cd Data/SQLParser && make test
+
   linux-gcc-cmake-sqlite-no-sqlparser:
     runs-on: ubuntu-24.04
     needs: changes

Data/Makefile

@@ -13,7 +13,7 @@ objects = AbstractBinder AbstractBinding AbstractExtraction AbstractExtractor \
 	Range RecordSet Row RowFilter RowFormatter RowIterator \
 	SimpleRowFormatter Session SessionFactory SessionImpl \
 	SessionPool SessionPoolContainer SQLChannel \
-	Statement StatementCreator StatementImpl Time Transcoder
+	Statement StatementCreator StatementImpl Time Transcoder Utility RenderingBinder
 
 ifndef POCO_DATA_NO_SQL_PARSER
 	objects += SQLParser SQLParserResult \

Data/SQLParser/Makefile

@@ -42,7 +42,12 @@ relaxed_build ?= "off"
 ifeq ($(relaxed_build), on)
     $(warning $(NAME) will be built with most compiler warnings deactivated. This is fine if you want to test $(NAME) but will become an issue when you want to contribute code.)
 else
-    LIB_CLFAGS += -Wall -Werror
+    LIB_CFLAGS += -Wall -Werror
+    # Clang: ensure files end with newline. Missing final newlines here triggered
+    # -Wnewline-eof warnings in downstream projects (e.g., Hyrise).
+    ifneq (,$(findstring clang,$(shell $(CXX) --version 2>/dev/null)))
+        LIB_CFLAGS += -Wnewline-eof
+    endif
 endif
 
 static ?= no
@@ -66,8 +71,14 @@ library: $(LIB_BUILD)
 $(LIB_BUILD): $(LIB_OBJ)
 	$(LIBLINKER) $(LIB_LFLAGS) $(LIB_BUILD) $(LIB_OBJ)
 
+# The auto-generated code from bison and flex contains some parts the compiler complains about with -Wall.
+# bison_parser.cpp #includes flex_lexer.h, so bison_parser.o must wait for flex_lexer.cpp regeneration
+# to finish (which also produces flex_lexer.h). Without this dep, parallel make races and bison_parser.o
+# can start before hsql_lex is declared, producing 'hsql_lex was not declared' errors.
 $(SRCPARSER)/flex_lexer.o: $(SRCPARSER)/flex_lexer.cpp $(SRCPARSER)/bison_parser.cpp
 	$(CXX) $(LIB_CFLAGS) -c -o $@ $< -Wno-sign-compare -Wno-unneeded-internal-declaration -Wno-register
+$(SRCPARSER)/bison_parser.o: $(SRCPARSER)/bison_parser.cpp $(SRCPARSER)/flex_lexer.cpp
+	$(CXX) $(LIB_CFLAGS) -c -o $@ $< -Wno-unused-but-set-variable
 
 %.o: %.cpp $(PARSER_CPP) $(LIB_H)
 	$(CXX) $(LIB_CFLAGS) -c -o $@ $<

Data/SQLParser/README.md

@@ -1,6 +1,6 @@
 C++ SQL Parser
 =========================
-[![Build Status](https://github.com/hyrise/sql-parser/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/hyrise/sql-parser/actions?query=branch%3Amaster)
+[![Build Status](https://github.com/hyrise/sql-parser/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/hyrise/sql-parser/actions?query=branch%3Amain)
 
 
 This is a SQL Parser for C++. It parses the given SQL query into C++ objects.
@@ -20,7 +20,7 @@ To use the SQL parser in your own projects you simply have to follow these few s
  3. *(Optional, Recommended)* Run `make install` to copy the library to `/usr/local/lib/`
  4. Run the tests `make test` to make sure everything worked
  5. Include the `SQLParser.h` from `src/` (or from `/usr/local/lib/hsql/` if you installed it) and link the library in your project
- 6. Take a look at the [example project here](https://github.com/hyrise/sql-parser/tree/master/example)
+ 6. Take a look at the [example project here](https://github.com/hyrise/sql-parser/tree/main/example)
 
 ```cpp
 #include "hsql/SQLParser.h"

Data/SQLParser/benchmark/benchmark.cpp

@@ -7,20 +7,20 @@ int main(int argc, char** argv) {
   // Create parse and tokenize benchmarks for TPC-H queries.
   const auto tpch_queries = getTPCHQueries();
   for (const auto& query : tpch_queries) {
-	std::string p_name = query.first + "-parse";
-	benchmark::RegisterBenchmark(p_name.c_str(), &BM_ParseBenchmark, query.second);
-	std::string t_name = query.first + "-tokenize";
-	benchmark::RegisterBenchmark(t_name.c_str(), &BM_TokenizeBenchmark, query.second);
+    std::string p_name = query.first + "-parse";
+    benchmark::RegisterBenchmark(p_name.c_str(), &BM_ParseBenchmark, query.second);
+    std::string t_name = query.first + "-tokenize";
+    benchmark::RegisterBenchmark(t_name.c_str(), &BM_TokenizeBenchmark, query.second);
   }
 
   // Create parse and tokenize benchmarks for all queries in sql_queries array.
   for (unsigned i = 0; i < sql_queries.size(); ++i) {
-	const auto& query = sql_queries[i];
-	std::string p_name = getQueryName(i) + "-parse";
-	benchmark::RegisterBenchmark(p_name.c_str(), &BM_ParseBenchmark, query.second);
+    const auto& query = sql_queries[i];
+    std::string p_name = getQueryName(i) + "-parse";
+    benchmark::RegisterBenchmark(p_name.c_str(), &BM_ParseBenchmark, query.second);
 
-	std::string t_name = getQueryName(i) + "-tokenize";
-	benchmark::RegisterBenchmark(t_name.c_str(), &BM_TokenizeBenchmark, query.second);
+    std::string t_name = getQueryName(i) + "-tokenize";
+    benchmark::RegisterBenchmark(t_name.c_str(), &BM_TokenizeBenchmark, query.second);
   }
 
   benchmark::Initialize(&argc, argv);

Data/SQLParser/benchmark/benchmark_utils.cpp

@@ -16,8 +16,8 @@ void BM_TokenizeBenchmark(benchmark::State& st, const std::string& query) {
   st.counters["num_chars"] = query.size();
 
   while (st.KeepRunning()) {
-	std::vector<int16_t> tokens(512);
-	hsql::SQLParser::tokenize(query, &tokens);
+    std::vector<int16_t> tokens(512);
+    hsql::SQLParser::tokenize(query, &tokens);
   }
 }
 
@@ -26,19 +26,19 @@ void BM_ParseBenchmark(benchmark::State& st, const std::string& query) {
   st.counters["num_chars"] = query.size();
 
   while (st.KeepRunning()) {
-	hsql::SQLParserResult result;
-	hsql::SQLParser::parse(query, &result);
-	if (!result.isValid()) {
-	  std::cout << query << std::endl;
-	  std::cout << result.errorMsg() << std::endl;
-	  st.SkipWithError("Parsing failed!");
-	}
+    hsql::SQLParserResult result;
+    hsql::SQLParser::parse(query, &result);
+    if (!result.isValid()) {
+      std::cout << query << std::endl;
+      std::cout << result.errorMsg() << std::endl;
+      st.SkipWithError("Parsing failed!");
+    }
   }
 }
 
 std::string readFileContents(const std::string& file_path) {
   std::ifstream t(file_path.c_str());
   std::string text((std::istreambuf_iterator<char>(t)),
-				   std::istreambuf_iterator<char>());
+                   std::istreambuf_iterator<char>());
   return text;
 }

Data/SQLParser/benchmark/benchmark_utils.h

@@ -22,13 +22,13 @@ std::string readFileContents(const std::string& file_path);
 
 #define PARSE_QUERY_BENCHMARK(name, query)\
   static void name(benchmark::State& st) {\
-	BM_ParseBenchmark(st, query);\
+    BM_ParseBenchmark(st, query);\
   }\
   BENCHMARK(name);
 
 #define TOKENIZE_QUERY_BENCHMARK(name, query)\
   static void name(benchmark::State& st) {\
-	BM_TokenizeBenchmark(st, query);\
+    BM_TokenizeBenchmark(st, query);\
   }\
   BENCHMARK(name);
 

Data/SQLParser/benchmark/parser_benchmark.cpp

@@ -24,14 +24,14 @@ static void BM_CharacterCount(benchmark::State& st) {
   st.counters["num_tokens"] = getNumTokens(query);
   st.counters["num_chars"] = query.size();
   while (st.KeepRunning()) {
-	hsql::SQLParserResult result;
-	hsql::SQLParser::parse(query, &result);
+    hsql::SQLParserResult result;
+    hsql::SQLParser::parse(query, &result);
   }
 }
 BENCHMARK(BM_CharacterCount)
   ->RangeMultiplier(1 << 2)
   ->Ranges({{1 << 5, 1 << 15},
-			{5, 5}});
+            {5, 5}});
 
 // Benchmark the influence of increasing number of tokens, while
 // the number of characters remains unchanged.
@@ -46,42 +46,42 @@ static void BM_ConditionalTokens(benchmark::State& st) {
   std::stringstream condStream;
   size_t missingTokens = numTokens - 4;
   if (missingTokens > 0) {
-	condStream << " WHERE a";
-	missingTokens -= 2;
+    condStream << " WHERE a";
+    missingTokens -= 2;
 
-	while (missingTokens > 0) {
-	  condStream << " AND a";
-	  missingTokens -= 2;
-	}
+    while (missingTokens > 0) {
+      condStream << " AND a";
+      missingTokens -= 2;
+    }
   }
 
   query += condStream.str();
 
   if (targetSize >= query.size()) {
-	const size_t pad = targetSize - query.size();
-	const std::string filler = std::string(pad, 'a');
-	query.replace(7, 1, filler);
+    const size_t pad = targetSize - query.size();
+    const std::string filler = std::string(pad, 'a');
+    query.replace(7, 1, filler);
 
   } else {
-	// Query can't be the same length as in the other benchmarks.
-	// Running this will result in unusable data.
-	fprintf(stderr, "Too many tokens. Query too long for benchmark char limit (%lu > %lu).\n",
-	  query.size(), targetSize);
-	return;
+    // Query can't be the same length as in the other benchmarks.
+    // Running this will result in unusable data.
+    fprintf(stderr, "Too many tokens. Query too long for benchmark char limit (%lu > %lu).\n",
+      query.size(), targetSize);
+    return;
   }
 
   st.counters["num_tokens"] = getNumTokens(query);
   st.counters["num_chars"] = query.size();
   while (st.KeepRunning()) {
-	hsql::SQLParserResult result;
-	hsql::SQLParser::parse(query, &result);
-	if (!result.isValid()) st.SkipWithError("Parsing failed!");
+    hsql::SQLParserResult result;
+    hsql::SQLParser::parse(query, &result);
+    if (!result.isValid()) st.SkipWithError("Parsing failed!");
   }
 }
 BENCHMARK(BM_ConditionalTokens)
   ->RangeMultiplier(1 << 2)
   ->Ranges({{1 << 14, 1 << 14},
-			{1 << 2, 1 << 11}});
+            {1 << 2, 1 << 11}});
 
 
 

Data/SQLParser/benchmark/queries.cpp

@@ -11,8 +11,8 @@ namespace filesystem = std::filesystem;
 
 std::string getQueryName(unsigned i) {
   if (sql_queries[i].first.empty()) {
-	std::string name = "#" + std::to_string(i + 1);
-	return name;
+    std::string name = "#" + std::to_string(i + 1);
+    return name;
   }
   return std::string("") + sql_queries[i].first;
 }
@@ -22,22 +22,22 @@ std::vector<SQLQuery> getQueriesFromDirectory(const std::string& dir_path) {
   std::vector<std::string> files;
 
   for (auto& entry : filesystem::directory_iterator(dir_path)) {
-	if (filesystem::is_regular_file(entry)) {
-	  std::string path_str = filesystem::path(entry);
+    if (filesystem::is_regular_file(entry)) {
+      std::string path_str = filesystem::path(entry);
 
-	  if (std::regex_search(path_str, query_file_regex)) {
-		files.push_back(path_str);
-	  }
-	}
+      if (std::regex_search(path_str, query_file_regex)) {
+        files.push_back(path_str);
+      }
+    }
   }
 
   std::sort(files.begin(), files.end());
 
   std::vector<SQLQuery> queries;
   for (const std::string& file_path : files) {
-	const filesystem::path p(file_path);
-	const std::string query = readFileContents(file_path);
-	queries.emplace_back(p.filename(), query);
+    const filesystem::path p(file_path);
+    const std::string query = readFileContents(file_path);
+    queries.emplace_back(p.filename(), query);
   }
   return queries;
 }

Data/SQLParser/src/SQLParser.cpp

@@ -15,9 +15,9 @@ bool SQLParser::parse(const std::string& sql, SQLParserResult* result) {
   YY_BUFFER_STATE state;
 
   if (hsql_lex_init(&scanner)) {
-	// Couldn't initialize the lexer.
-	fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
-	return false;
+    // Couldn't initialize the lexer.
+    fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
+    return false;
   }
   const char* text = sql.c_str();
   state = hsql__scan_string(text, scanner);
@@ -44,8 +44,8 @@ bool SQLParser::tokenize(const std::string& sql, std::vector<int16_t>* tokens) {
   // Initialize the scanner.
   yyscan_t scanner;
   if (hsql_lex_init(&scanner)) {
-	fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
-	return false;
+    fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
+    return false;
   }
 
   YY_BUFFER_STATE state;
@@ -54,16 +54,21 @@ bool SQLParser::tokenize(const std::string& sql, std::vector<int16_t>* tokens) {
   YYSTYPE yylval;
   YYLTYPE yylloc;
 
-  // Step through the string until EOF is read.
-  // Note: hsql_lex returns int, but we know that its range is within 16 bit.
-  int16_t token = hsql_lex(&yylval, &yylloc, scanner);
-  while (token != 0) {
-	tokens->push_back(token);
-	token = hsql_lex(&yylval, &yylloc, scanner);
-
-	if (token == SQL_IDENTIFIER || token == SQL_STRING) {
-	  free(yylval.sval);
-	}
+  // Step through the string until EOF is read. Each lex pass that returns
+  // an sval-bearing token (SQL_IDENTIFIER, SQL_STRING, SQL_NAMED_PARAM)
+  // allocates yylval.sval via strdup / hsql::substr; free it before the
+  // next lex call overwrites yylval. The previous loop shape lexed twice
+  // before freeing, which leaked the first sval-bearing token and missed
+  // SQL_NAMED_PARAM entirely. The set mirrors bison's `%destructor
+  // { free($$); } <sval>` for the same tokens.
+  // Note: hsql_lex returns int, but we know its range is within 16 bit.
+  while (true) {
+    int16_t token = hsql_lex(&yylval, &yylloc, scanner);
+    if (token == 0) break;
+    tokens->push_back(token);
+    if (token == SQL_IDENTIFIER || token == SQL_STRING || token == SQL_NAMED_PARAM) {
+      free(yylval.sval);
+    }
   }
 
   hsql__delete_buffer(state, scanner);