Add support for DELETE statements

renecannao · renecannao · commit f0212734e7c1 · 2025-05-19T21:46:53.000Z
diff --git a/examples/main_mysql_example.cpp b/examples/main_mysql_example.cpp
@@ -1,43 +1,104 @@
-#include "mysql_parser/mysql_parser.h" // Changed include path and namespace
+#include "mysql_parser/mysql_parser.h" // Ensure this path is correct for your include setup
 #include <iostream>
 #include <vector>
 #include <string>
 
+void parse_and_print(MysqlParser::Parser& parser, const std::string& query_type, const std::string& query) {
+    std::cout << "------------------------------------------\n";
+    std::cout << "Parsing MySQL " << query_type << " query: " << query << std::endl;
+
+    parser.clearErrors();
+    std::unique_ptr<MysqlParser::AstNode> ast = parser.parse(query);
+
+    if (ast) {
+        std::cout << "Parsing successful!" << std::endl;
+        MysqlParser::print_ast(ast.get());
+    } else {
+        std::cout << "Parsing failed." << std::endl;
+        const auto& errors = parser.getErrors();
+        if (errors.empty()) {
+            std::cout << "  (No specific error messages, check parser logic or mysql_yyerror)" << std::endl;
+        } else {
+            for (const auto& error : errors) {
+                std::cout << "  Error: " << error << std::endl;
+            }
+        }
+    }
+}
+
 int main() {
-    MysqlParser::Parser parser; // Changed namespace
+    MysqlParser::Parser parser;
 
-    std::vector<std::string> queries = {
+    std::vector<std::string> select_queries = {
         "SELECT name FROM users;",
-        "SELECT * FROM `orders`;", // MySQL backticked identifier
+        "SELECT * FROM `orders`;",
+        "SELECT * FROM tablenameB" // No semicolon
+    };
+
+    std::vector<std::string> insert_queries = {
         "INSERT INTO products VALUES ('a new gadget');",
-        "INSERT INTO logs VALUES (\"Error message with double quotes\");", // MySQL double quotes
-        "INSERT INTO `special-table` VALUES ('escaped value \\'single quote\\' and \\\\ backslash');", // MySQL escapes
-        "QUIT", // MySQL often doesn't require semicolon for last statement in a batch
-        "SELECT * FROM WHERE;", 
-        "INSERT INTO logs VALUES (no_quotes_here);" 
+        "INSERT INTO logs VALUES (\"Error message with double quotes\")", // No semicolon
+        "INSERT INTO `special-table` VALUES ('escaped value \\'single quote\\' and \\\\ backslash');"
     };
 
-    for (const auto& query : queries) {
-        std::cout << "------------------------------------------\n";
-        std::cout << "Parsing MySQL query: " << query << std::endl;
-        
-        parser.clearErrors(); 
-        std::unique_ptr<MysqlParser::AstNode> ast = parser.parse(query); // Changed namespace
+    std::vector<std::string> set_queries = {
+        "SET @my_user_var = 'hello world';",
+        "SET @anotherVar = 12345;",
+        "SET global max_connections = 1000", // No semicolon
+        "SET @@session.net_write_timeout = 120;",
+        "SET NAMES 'utf8mb4' COLLATE 'utf8mb4_unicode_ci';",
+        "SET CHARACTER SET DEFAULT",
+        "SET @a = 1, @b = 'two', global max_heap_table_size = 128000000;"
+    };
 
-        if (ast) {
-            std::cout << "Parsing successful!" << std::endl;
-            MysqlParser::print_ast(ast.get()); // Changed namespace
-        } else {
-            std::cout << "Parsing failed." << std::endl;
-            const auto& errors = parser.getErrors();
-            if (errors.empty()) {
-                std::cout << "  (No specific error messages, check parser logic or mysql_yyerror)" << std::endl;
-            } else {
-                for (const auto& error : errors) {
-                    std::cout << "  Error: " << error << std::endl;
-                }
-            }
-        }
+    std::vector<std::string> delete_queries = {
+        // Single-table DELETE statements
+        "DELETE FROM customers WHERE customer_id = 101;",
+        "DELETE LOW_PRIORITY FROM orders WHERE order_date < '2023-01-01'",
+        "DELETE QUICK IGNORE FROM logs WHERE log_level = 'DEBUG' ORDER BY timestamp DESC LIMIT 1000;",
+        "DELETE FROM events WHERE event_name = `expired-event`", // Backticked identifier for value
+
+        // Multi-table DELETE statements (simplified, based on current grammar)
+        "DELETE t1 FROM table1 AS t1, table2 AS t2 WHERE t1.id = t2.ref_id;", // Needs table_reference_list_placeholder to be more robust
+        "DELETE FROM t1, t2 USING table1 AS t1 INNER JOIN table2 AS t2 ON t1.key = t2.key WHERE t1.value > 100;", // Also simplified
+
+        // DELETE without semicolon
+        "DELETE FROM old_records WHERE last_accessed < '2020-01-01'",
+
+        // Potentially problematic or error cases for DELETE
+        "DELETE quick low_priority from test_table", // Order of options might matter or not be fully supported yet
+        "DELETE FROM table1 WHERE id = ", // Incomplete WHERE
+        "DELETE tbl1 tbl2 FROM table_references" // Common MySQL multi-table, current grammar might simplify tbl1, tbl2 part
+    };
+
+
+    std::cout << "\n======= SELECT QUERIES =======\n";
+    for (const auto& query : select_queries) {
+        parse_and_print(parser, "SELECT", query);
+    }
+
+    std::cout << "\n======= INSERT QUERIES =======\n";
+    for (const auto& query : insert_queries) {
+        parse_and_print(parser, "INSERT", query);
     }
+
+    std::cout << "\n======= SET QUERIES =======\n";
+    for (const auto& query : set_queries) {
+        parse_and_print(parser, "SET", query);
+    }
+
+    std::cout << "\n======= DELETE QUERIES =======\n";
+    for (const auto& query : delete_queries) {
+        parse_and_print(parser, "DELETE", query);
+    }
+
+    // Example of a known failing query (due to function call in expression_placeholder)
+    std::cout << "\n======= KNOWN FAILING SET QUERY (Function Call) =======\n";
+    parse_and_print(parser, "SET", "SET @myvar = some_function(1, 'a');");
+
+    std::cout << "\n======= KNOWN FAILING SET QUERY (Invalid Identifier) =======\n";
+    parse_and_print(parser, "SET", "SET global invalid-variable = 100;");
+
+
     return 0;
 }
diff --git a/include/mysql_parser/mysql_ast.h b/include/mysql_parser/mysql_ast.h
@@ -4,27 +4,38 @@
 #include <string>
 #include <vector>
 #include <iostream>
-#include <algorithm> 
+#include <algorithm>
 
-namespace MysqlParser { // Changed namespace
+namespace MysqlParser {
 
-// NodeType enum can be identical for this stage, or diverge later
 enum class NodeType {
     NODE_UNKNOWN,
     NODE_COMMAND,
     NODE_SELECT_STATEMENT,
     NODE_INSERT_STATEMENT,
+    NODE_DELETE_STATEMENT,
     NODE_IDENTIFIER,
     NODE_STRING_LITERAL,
     NODE_ASTERISK,
     NODE_SET_STATEMENT,
-    NODE_VARIABLE_ASSIGNMENT,   // for @var = expr or sysvar = expr
-    NODE_USER_VARIABLE,         // for @varname
-    NODE_SYSTEM_VARIABLE,       // for sysvar (can have scope)
-    NODE_VARIABLE_SCOPE,        // GLOBAL, SESSION, PERSIST, PERSIST_ONLY
-    NODE_EXPRESSION_PLACEHOLDER,// Placeholder for complex expressions
-    NODE_SET_NAMES,             // for SET NAMES
-    NODE_SET_CHARSET            // for SET CHARSET
+    NODE_VARIABLE_ASSIGNMENT,
+    NODE_USER_VARIABLE,
+    NODE_SYSTEM_VARIABLE,
+    NODE_VARIABLE_SCOPE,
+    NODE_EXPRESSION_PLACEHOLDER,
+    NODE_SET_NAMES,
+    NODE_SET_CHARSET,
+    NODE_DELETE_OPTIONS,
+    NODE_TABLE_NAME_LIST,
+    NODE_FROM_CLAUSE,
+    NODE_USING_CLAUSE,
+    NODE_WHERE_CLAUSE,
+    NODE_ORDER_BY_CLAUSE,
+    NODE_ORDER_BY_ITEM,
+    NODE_LIMIT_CLAUSE,
+    NODE_COMPARISON_EXPRESSION,
+    NODE_OPERATOR,
+    NODE_QUALIFIED_IDENTIFIER
 };
 
 struct AstNode {
@@ -63,6 +74,7 @@ inline void print_ast(const AstNode* node, int indent = 0) {
         case NodeType::NODE_COMMAND: type_str = "COMMAND"; break;
         case NodeType::NODE_SELECT_STATEMENT: type_str = "SELECT_STMT"; break;
         case NodeType::NODE_INSERT_STATEMENT: type_str = "INSERT_STMT"; break;
+        case NodeType::NODE_DELETE_STATEMENT: type_str = "DELETE_STMT"; break;
         case NodeType::NODE_IDENTIFIER: type_str = "IDENTIFIER"; break;
         case NodeType::NODE_STRING_LITERAL: type_str = "STRING_LITERAL"; break;
         case NodeType::NODE_ASTERISK: type_str = "ASTERISK"; break;
@@ -74,6 +86,17 @@ inline void print_ast(const AstNode* node, int indent = 0) {
         case NodeType::NODE_EXPRESSION_PLACEHOLDER: type_str = "EXPR_PLACEHOLDER"; break;
         case NodeType::NODE_SET_NAMES: type_str = "SET_NAMES"; break;
         case NodeType::NODE_SET_CHARSET: type_str = "SET_CHARSET"; break;
+        case NodeType::NODE_DELETE_OPTIONS: type_str = "DELETE_OPTIONS"; break;
+        case NodeType::NODE_TABLE_NAME_LIST: type_str = "TABLE_NAME_LIST"; break;
+        case NodeType::NODE_FROM_CLAUSE: type_str = "FROM_CLAUSE"; break;
+        case NodeType::NODE_USING_CLAUSE: type_str = "USING_CLAUSE"; break;
+        case NodeType::NODE_WHERE_CLAUSE: type_str = "WHERE_CLAUSE"; break;
+        case NodeType::NODE_ORDER_BY_CLAUSE: type_str = "ORDER_BY_CLAUSE"; break;
+        case NodeType::NODE_ORDER_BY_ITEM: type_str = "ORDER_BY_ITEM"; break;
+        case NodeType::NODE_LIMIT_CLAUSE: type_str = "LIMIT_CLAUSE"; break;
+        case NodeType::NODE_COMPARISON_EXPRESSION: type_str = "COMPARISON_EXPR"; break;
+        case NodeType::NODE_OPERATOR: type_str = "OPERATOR"; break; // <<< ADDED CASE
+        case NodeType::NODE_QUALIFIED_IDENTIFIER: type_str = "QUALIFIED_IDENTIFIER"; break;
         default: type_str = "UNHANDLED_TYPE(" + std::to_string(static_cast<int>(node->type)) + ")"; break;
     }
     std::cout << "Type: " << type_str << ", Value: '" << node->value << "'" << std::endl;
diff --git a/src/mysql_parser/mysql_lexer.l b/src/mysql_parser/mysql_lexer.l
@@ -3,21 +3,28 @@
 %option extra-type="MysqlParser::Parser*"
 
 %{
-#include "mysql_parser/mysql_parser.h"
-#include "mysql_parser/mysql_ast.h"
-#include "mysql_parser.tab.h" // Will be mysql_parser.tab.h
+#include "mysql_parser/mysql_parser.h"   // For MysqlParser::Parser, yyscan_t
+#include "mysql_parser/mysql_ast.h"      // For MysqlParser::AstNode, etc.
+#include "mysql_parser.tab.h"           // Bison-generated: token enums, defines union MYSQL_YYSTYPE and YYSTYPE
 #include <string>
 #include <vector>
 
-// YY_DECL to control the signature of mysql_yylex
+// YY_DECL to control the signature of the generated mysql_yylex function.
+// This signature MUST match how Bison calls it (influenced by %lex-param in .y file
+// and the extern declaration of mysql_yylex in the .y file's prologue).
+// We use the explicit union name as deduced from previous Bison error messages.
+// The actual definition of 'union MYSQL_YYSTYPE' comes from "mysql_parser.tab.h".
 union MYSQL_YYSTYPE; // Forward declare for YY_DECL (Bison defines this in mysql_parser.tab.h)
 #undef YY_DECL
 #define YY_DECL int mysql_yylex (union MYSQL_YYSTYPE *yylval_param, yyscan_t yyscanner, MysqlParser::Parser* parser_context)
 
-// #define YY_USER_DATA ((MysqlParser::Parser*)yyget_extra(yyscanner)) // Alternative way to access context
+// YY_USER_DATA can be used to access parser_context IF it's passed as yyextra,
+// OR if parser_context from YY_DECL is directly used.
+// Since parser_context is now a direct parameter to mysql_yylex via YY_DECL,
+// we can use it directly in actions.
+// #define YY_USER_DATA ((MysqlParser::Parser*)yyget_extra(yyscanner))
 %}
 
-/* Declare exclusive start conditions */
 %x COMMENT
 %x SQSTRING
 %x DQSTRING
@@ -27,9 +34,9 @@ union MYSQL_YYSTYPE; // Forward declare for YY_DECL (Bison defines this in mysql
 
 <INITIAL>{
   "/*"                  { BEGIN(COMMENT); }
-  "-- ".* { /* MySQL -- comment (note space) */ }
-  "--\n"                { /* MySQL -- comment followed by newline */ }
-  "#".* { /* MySQL # comment */ }
+  "-- ".* { /* MySQL -- comment (note space); no action, just ignore */ }
+  "--\n"                { /* MySQL -- comment followed by newline; no action */ }
+  "#".* { /* MySQL # comment; no action */ }
 
   [ \t\n]+              { /* Ignore whitespace */ }
 
@@ -50,16 +57,30 @@ union MYSQL_YYSTYPE; // Forward declare for YY_DECL (Bison defines this in mysql
   "DEFAULT"             { return TOKEN_DEFAULT; }
   "COLLATE"             { return TOKEN_COLLATE; }
 
+  "DELETE"              { return TOKEN_DELETE; }
+  "LOW_PRIORITY"        { return TOKEN_LOW_PRIORITY; }
+  "QUICK"               { return TOKEN_QUICK; }
+  "IGNORE"              { return TOKEN_IGNORE_SYM; }
+  "USING"               { return TOKEN_USING; }
+  "ORDER"               { return TOKEN_ORDER; }
+  "BY"                  { return TOKEN_BY; }
+  "LIMIT"               { return TOKEN_LIMIT; }
+  "ASC"                 { return TOKEN_ASC; }
+  "DESC"                { return TOKEN_DESC; }
+  "WHERE"               { return TOKEN_WHERE; }
+  "AS"                  { return TOKEN_AS; }
+
+
   "`"                   { yylval_param->str_val = new std::string(); BEGIN(BTIDENT); }
 
   "@@global."           { return TOKEN_GLOBAL_VAR_PREFIX; }
   "@@session."          { return TOKEN_SESSION_VAR_PREFIX; }
   "@@local."            { return TOKEN_SESSION_VAR_PREFIX; } /* Alias for session */
-  "@@persisted."        { /* Placeholder if you add specific handling */ return TOKEN_PERSIST_VAR_PREFIX; }
+  "@@persisted."        { return TOKEN_PERSIST_VAR_PREFIX; } /* If you add specific handling */
   "@@"                  { return TOKEN_DOUBLESPECIAL; }
   "@"                   { return TOKEN_SPECIAL; }
 
-  [a-zA-Z_][a-zA-Z0-9_]* { /* Does not include hyphen for now */
+  [a-zA-Z_][a-zA-Z0-9_]* {
                           yylval_param->str_val = new std::string(yytext);
                           return TOKEN_IDENTIFIER;
                         }
@@ -71,10 +92,18 @@ union MYSQL_YYSTYPE; // Forward declare for YY_DECL (Bison defines this in mysql
   "("                   { return TOKEN_LPAREN; }
   ")"                   { return TOKEN_RPAREN; }
   ";"                   { return TOKEN_SEMICOLON; }
-  "="                   { return TOKEN_EQUAL; }
   "."                   { return TOKEN_DOT; }
   ","                   { return TOKEN_COMMA; }
 
+  "="                   { return TOKEN_EQUAL; }
+  "<"                   { return TOKEN_LESS; }
+  ">"                   { return TOKEN_GREATER; }
+  "<="                  { return TOKEN_LESS_EQUAL; }
+  ">="                  { return TOKEN_GREATER_EQUAL; }
+  "!="                  { return TOKEN_NOT_EQUAL; }
+  "<>"                  { return TOKEN_NOT_EQUAL; }
+
+
   [0-9]+("."[0-9]+)?    { yylval_param->str_val = new std::string(yytext); return TOKEN_NUMBER_LITERAL;}
 
   .                     {
@@ -83,7 +112,7 @@ union MYSQL_YYSTYPE; // Forward declare for YY_DECL (Bison defines this in mysql
                           if (parser_context) {
                               parser_context->internal_add_error(err_msg);
                           } else {
-                              fprintf(stderr, "%s\n", err_msg);
+                              fprintf(stderr, "%s\n", err_msg); // Fallback
                           }
                         }
 }
@@ -99,27 +128,30 @@ union MYSQL_YYSTYPE; // Forward declare for YY_DECL (Bison defines this in mysql
   "[^'\\\\]+"           { *(yylval_param->str_val) += yytext; }
   "\\'"                 { *(yylval_param->str_val) += "'"; }
   "\\\\"                { *(yylval_param->str_val) += "\\"; }
-  "''"                  { *(yylval_param->str_val) += "'"; }
+  "''"                  { *(yylval_param->str_val) += "'"; } /* MySQL: '' inside string is a literal ' */
   "'"                   { *(yylval_param->str_val) += "'"; BEGIN(INITIAL); return TOKEN_STRING_LITERAL; }
-  <<EOF>>               { if(parser_context) parser_context->internal_add_error("Unterminated single-quoted string"); BEGIN(INITIAL); return YY_NULL; }
+  <<EOF>>               { if(parser_context) parser_context->internal_add_error("Unterminated single-quoted string"); BEGIN(INITIAL); return YY_NULL; /* Return 0 for EOF/error */ }
 }
 
 <DQSTRING>{
   "[^\"\\\\]+"          { *(yylval_param->str_val) += yytext; }
   "\\\""                { *(yylval_param->str_val) += "\""; }
   "\\\\"                { *(yylval_param->str_val) += "\\"; }
-  "\"\""                { *(yylval_param->str_val) += "\""; }
+  "\"\""                { *(yylval_param->str_val) += "\""; } /* MySQL: "" inside string is a literal " */
   "\""                  { *(yylval_param->str_val) += "\""; BEGIN(INITIAL); return TOKEN_STRING_LITERAL; }
   <<EOF>>               { if(parser_context) parser_context->internal_add_error("Unterminated double-quoted string"); BEGIN(INITIAL); return YY_NULL; }
 }
 
 <BTIDENT>{
-  "`"                   { BEGIN(INITIAL); return TOKEN_IDENTIFIER; } // Returns the accumulated string
-  "``"                  { *(yylval_param->str_val) += '`'; }
+  "`"                   { BEGIN(INITIAL); return TOKEN_IDENTIFIER; } /* Returns the accumulated string */
+  "``"                  { *(yylval_param->str_val) += '`'; } /* `` inside backticks is a literal ` */
   [^`\n]+               { *(yylval_param->str_val) += yytext; }
-  \n                    { if(parser_context) parser_context->internal_add_error("Newline in backticked identifier"); BEGIN(INITIAL); /* No explicit return */ }
+  \n                    { if(parser_context) parser_context->internal_add_error("Newline in backticked identifier"); BEGIN(INITIAL); /* No explicit return, lexer will find next token or error */ }
   <<EOF>>               { if(parser_context) parser_context->internal_add_error("Unterminated backticked identifier"); BEGIN(INITIAL); return YY_NULL; }
 }
 
 %%
 
+// yywrap is not strictly needed due to %option noyywrap
+// int mysql_yywrap(yyscan_t scanner) { return 1; }
+
diff --git a/src/mysql_parser/mysql_parser.y b/src/mysql_parser/mysql_parser.y
