feat: SELECT * EXCEPT/REPLACE column modifiers (#20)

renecannao · renecannao · commit a62343ce67cb · 2026-04-12T20:54:47.000Z
Add BigQuery-style star modifier syntax for both MySQL and PostgreSQL
dialects: SELECT * EXCEPT(col1, col2) and SELECT * REPLACE(expr AS col).
Supports table-qualified stars (e.g. t.* EXCEPT(...)) and multiple
replacement items. Includes parser, emitter round-trip, and 7 new tests.
diff --git a/Makefile b/Makefile
@@ -83,7 +83,8 @@ TEST_SRCS = $(TEST_DIR)/test_main.cpp \
             $(TEST_DIR)/test_datetime_format.cpp \
             $(TEST_DIR)/test_datetime_funcs.cpp \
             $(TEST_DIR)/test_result_set.cpp \
-            $(TEST_DIR)/test_ssl_config.cpp
+            $(TEST_DIR)/test_ssl_config.cpp \
+            $(TEST_DIR)/test_star_modifiers.cpp
 TEST_OBJS = $(TEST_SRCS:.cpp=.o)
 TEST_TARGET = $(PROJECT_ROOT)/run_tests
 
diff --git a/include/sql_parser/common.h b/include/sql_parser/common.h
@@ -204,6 +204,11 @@ enum class NodeType : uint16_t {
     NODE_CTE,                  // WITH clause wrapper
     NODE_CTE_DEFINITION,       // name AS (SELECT ...)
 
+    // Star modifiers (BigQuery-style)
+    NODE_STAR_EXCEPT,          // SELECT * EXCEPT(col1, col2)
+    NODE_STAR_REPLACE,         // SELECT * REPLACE(expr AS col)
+    NODE_REPLACE_ITEM,         // single expr AS col inside REPLACE
+
     // Shared
     NODE_STMT_OPTIONS,         // LOW_PRIORITY, IGNORE, QUICK, DELAYED, etc.
     NODE_UPDATE_SET_ITEM,      // single col=expr pair (shared by INSERT SET and UPDATE SET)
diff --git a/include/sql_parser/emitter.h b/include/sql_parser/emitter.h
@@ -72,6 +72,11 @@ class Emitter {
             case NodeType::NODE_STMT_OPTIONS:    emit_stmt_options(node); break;
             case NodeType::NODE_UPDATE_SET_ITEM: emit_update_set_item(node); break;
 
+            // ---- Star modifiers ----
+            case NodeType::NODE_STAR_EXCEPT:  emit_star_except(node); break;
+            case NodeType::NODE_STAR_REPLACE: emit_star_replace(node); break;
+            case NodeType::NODE_REPLACE_ITEM: emit_replace_item(node); break;
+
             // ---- Compound query ----
             case NodeType::NODE_COMPOUND_QUERY:  emit_compound_query(node); break;
             case NodeType::NODE_SET_OPERATION:   emit_set_operation(node); break;
@@ -1164,6 +1169,44 @@ class Emitter {
         sb_.append(").");
         if (field) emit_node(field);
     }
+
+    void emit_star_except(const AstNode* node) {
+        const AstNode* star = node->first_child;
+        if (star) emit_node(star);
+        sb_.append(" EXCEPT(");
+        bool first = true;
+        for (const AstNode* col = star ? star->next_sibling : node->first_child;
+             col; col = col->next_sibling) {
+            if (!first) sb_.append(", ");
+            first = false;
+            emit_node(col);
+        }
+        sb_.append_char(')');
+    }
+
+    void emit_star_replace(const AstNode* node) {
+        const AstNode* star = node->first_child;
+        if (star) emit_node(star);
+        sb_.append(" REPLACE(");
+        bool first = true;
+        for (const AstNode* item = star ? star->next_sibling : node->first_child;
+             item; item = item->next_sibling) {
+            if (!first) sb_.append(", ");
+            first = false;
+            emit_node(item);
+        }
+        sb_.append_char(')');
+    }
+
+    void emit_replace_item(const AstNode* node) {
+        const AstNode* expr = node->first_child;
+        const AstNode* col = expr ? expr->next_sibling : nullptr;
+        if (expr) emit_node(expr);
+        if (col) {
+            sb_.append(" AS ");
+            emit_node(col);
+        }
+    }
 };
 
 } // namespace sql_parser
diff --git a/include/sql_parser/expression_parser.h b/include/sql_parser/expression_parser.h
@@ -676,6 +676,7 @@ class ExpressionParser {
             case TokenType::TK_LAST_VALUE:
             case TokenType::TK_PARTITION:
             case TokenType::TK_RECURSIVE:
+            case TokenType::TK_REPLACE:
                 return true;
             default:
                 return false;
diff --git a/include/sql_parser/select_parser.h b/include/sql_parser/select_parser.h
@@ -160,6 +160,70 @@ class SelectParser {
 
         AstNode* expr = expr_parser_.parse();
         if (!expr) return nullptr;
+
+        // Check for * EXCEPT(...) or * REPLACE(...)
+        bool is_star = (expr->type == NodeType::NODE_ASTERISK);
+        if (!is_star && expr->type == NodeType::NODE_QUALIFIED_NAME) {
+            for (const AstNode* c = expr->first_child; c; c = c->next_sibling) {
+                if (!c->next_sibling) {
+                    // table.* produces NODE_IDENTIFIER with value "*"
+                    if (c->type == NodeType::NODE_ASTERISK) {
+                        is_star = true;
+                    } else if (c->type == NodeType::NODE_IDENTIFIER &&
+                               c->value_len == 1 && c->value_ptr[0] == '*') {
+                        is_star = true;
+                    }
+                }
+            }
+        }
+
+        if (is_star) {
+            Token next = tok_.peek();
+            if (next.type == TokenType::TK_EXCEPT) {
+                tok_.skip();
+                AstNode* except_node = make_node(arena_, NodeType::NODE_STAR_EXCEPT);
+                except_node->add_child(expr);
+                if (tok_.peek().type == TokenType::TK_LPAREN) {
+                    tok_.skip();
+                    while (tok_.peek().type != TokenType::TK_RPAREN &&
+                           tok_.peek().type != TokenType::TK_EOF) {
+                        Token col = tok_.next_token();
+                        AstNode* col_node = make_node(arena_, NodeType::NODE_IDENTIFIER, col.text);
+                        except_node->add_child(col_node);
+                        if (tok_.peek().type == TokenType::TK_COMMA) tok_.skip();
+                    }
+                    if (tok_.peek().type == TokenType::TK_RPAREN) tok_.skip();
+                }
+                item->add_child(except_node);
+                return item;
+            }
+            if (next.type == TokenType::TK_REPLACE) {
+                tok_.skip();
+                AstNode* replace_node = make_node(arena_, NodeType::NODE_STAR_REPLACE);
+                replace_node->add_child(expr);
+                if (tok_.peek().type == TokenType::TK_LPAREN) {
+                    tok_.skip();
+                    while (tok_.peek().type != TokenType::TK_RPAREN &&
+                           tok_.peek().type != TokenType::TK_EOF) {
+                        AstNode* replace_expr = expr_parser_.parse();
+                        AstNode* replace_item = make_node(arena_, NodeType::NODE_REPLACE_ITEM);
+                        if (replace_expr) replace_item->add_child(replace_expr);
+                        if (tok_.peek().type == TokenType::TK_AS) {
+                            tok_.skip();
+                            Token col = tok_.next_token();
+                            AstNode* col_node = make_node(arena_, NodeType::NODE_IDENTIFIER, col.text);
+                            replace_item->add_child(col_node);
+                        }
+                        replace_node->add_child(replace_item);
+                        if (tok_.peek().type == TokenType::TK_COMMA) tok_.skip();
+                    }
+                    if (tok_.peek().type == TokenType::TK_RPAREN) tok_.skip();
+                }
+                item->add_child(replace_node);
+                return item;
+            }
+        }
+
         item->add_child(expr);
 
         // Optional alias: AS name, or just name (implicit alias)
diff --git a/include/sql_parser/table_ref_parser.h b/include/sql_parser/table_ref_parser.h
@@ -237,6 +237,7 @@ class TableRefParser {
             case TokenType::TK_OVER:
             case TokenType::TK_WITH:
             case TokenType::TK_PARTITION:
+            case TokenType::TK_REPLACE:
                 return false;
             default:
                 return true;  // Keywords not in the blocklist can be implicit aliases
diff --git a/tests/test_star_modifiers.cpp b/tests/test_star_modifiers.cpp
@@ -0,0 +1,166 @@
+#include <gtest/gtest.h>
+#include "sql_parser/parser.h"
+#include "sql_parser/emitter.h"
+
+using namespace sql_parser;
+
+class MySQLStarModifiersTest : public ::testing::Test {
+protected:
+    Parser<Dialect::MySQL> parser;
+
+    const AstNode* find_child(const AstNode* node, NodeType type) {
+        for (const AstNode* c = node->first_child; c; c = c->next_sibling) {
+            if (c->type == type) return c;
+        }
+        return nullptr;
+    }
+
+    std::string round_trip(const char* sql) {
+        auto r = parser.parse(sql, strlen(sql));
+        if (!r.ast) return "[PARSE_FAILED]";
+        Emitter<Dialect::MySQL> emitter(parser.arena());
+        emitter.emit(r.ast);
+        StringRef result = emitter.result();
+        return std::string(result.ptr, result.len);
+    }
+};
+
+class PgSQLStarModifiersTest : public ::testing::Test {
+protected:
+    Parser<Dialect::PostgreSQL> parser;
+
+    std::string round_trip(const char* sql) {
+        auto r = parser.parse(sql, strlen(sql));
+        if (!r.ast) return "[PARSE_FAILED]";
+        Emitter<Dialect::PostgreSQL> emitter(parser.arena());
+        emitter.emit(r.ast);
+        StringRef result = emitter.result();
+        return std::string(result.ptr, result.len);
+    }
+};
+
+// ========== EXCEPT ==========
+
+TEST_F(MySQLStarModifiersTest, SelectStarExcept) {
+    const char* sql = "SELECT * EXCEPT(id, created_at) FROM users";
+    auto r = parser.parse(sql, strlen(sql));
+    EXPECT_EQ(r.status, ParseResult::OK);
+    EXPECT_EQ(r.stmt_type, StmtType::SELECT);
+    ASSERT_NE(r.ast, nullptr);
+
+    // Find SELECT_ITEM_LIST -> SELECT_ITEM -> STAR_EXCEPT
+    auto* items = find_child(r.ast, NodeType::NODE_SELECT_ITEM_LIST);
+    ASSERT_NE(items, nullptr);
+    auto* item = items->first_child;
+    ASSERT_NE(item, nullptr);
+    auto* except_node = find_child(item, NodeType::NODE_STAR_EXCEPT);
+    ASSERT_NE(except_node, nullptr);
+
+    // First child is the asterisk, then the excluded columns
+    auto* star = except_node->first_child;
+    ASSERT_NE(star, nullptr);
+    EXPECT_EQ(star->type, NodeType::NODE_ASTERISK);
+
+    auto* col1 = star->next_sibling;
+    ASSERT_NE(col1, nullptr);
+    EXPECT_EQ(col1->type, NodeType::NODE_IDENTIFIER);
+
+    auto* col2 = col1->next_sibling;
+    ASSERT_NE(col2, nullptr);
+    EXPECT_EQ(col2->type, NodeType::NODE_IDENTIFIER);
+}
+
+TEST_F(MySQLStarModifiersTest, SelectQualifiedStarExcept) {
+    const char* sql = "SELECT users.* EXCEPT(password) FROM users";
+    auto r = parser.parse(sql, strlen(sql));
+    EXPECT_EQ(r.status, ParseResult::OK);
+    EXPECT_EQ(r.stmt_type, StmtType::SELECT);
+    ASSERT_NE(r.ast, nullptr);
+
+    auto* items = find_child(r.ast, NodeType::NODE_SELECT_ITEM_LIST);
+    ASSERT_NE(items, nullptr);
+    auto* item = items->first_child;
+    ASSERT_NE(item, nullptr);
+    auto* except_node = find_child(item, NodeType::NODE_STAR_EXCEPT);
+    ASSERT_NE(except_node, nullptr);
+
+    // First child is qualified name (users.*), then excluded column
+    auto* qname = except_node->first_child;
+    ASSERT_NE(qname, nullptr);
+    EXPECT_EQ(qname->type, NodeType::NODE_QUALIFIED_NAME);
+}
+
+// ========== REPLACE ==========
+
+TEST_F(MySQLStarModifiersTest, SelectStarReplace) {
+    const char* sql = "SELECT * REPLACE(UPPER(name) AS name) FROM users";
+    auto r = parser.parse(sql, strlen(sql));
+    EXPECT_EQ(r.status, ParseResult::OK);
+    EXPECT_EQ(r.stmt_type, StmtType::SELECT);
+    ASSERT_NE(r.ast, nullptr);
+
+    auto* items = find_child(r.ast, NodeType::NODE_SELECT_ITEM_LIST);
+    ASSERT_NE(items, nullptr);
+    auto* item = items->first_child;
+    ASSERT_NE(item, nullptr);
+    auto* replace_node = find_child(item, NodeType::NODE_STAR_REPLACE);
+    ASSERT_NE(replace_node, nullptr);
+
+    // First child is asterisk, then REPLACE_ITEM(s)
+    auto* star = replace_node->first_child;
+    ASSERT_NE(star, nullptr);
+    EXPECT_EQ(star->type, NodeType::NODE_ASTERISK);
+
+    auto* ritem = star->next_sibling;
+    ASSERT_NE(ritem, nullptr);
+    EXPECT_EQ(ritem->type, NodeType::NODE_REPLACE_ITEM);
+}
+
+// ========== Round-trip ==========
+
+TEST_F(MySQLStarModifiersTest, RoundTripExcept) {
+    std::string out = round_trip("SELECT * EXCEPT(id, created_at) FROM users");
+    EXPECT_NE(out.find("EXCEPT"), std::string::npos);
+    EXPECT_NE(out.find("id"), std::string::npos);
+    EXPECT_NE(out.find("created_at"), std::string::npos);
+}
+
+TEST_F(MySQLStarModifiersTest, RoundTripReplace) {
+    std::string out = round_trip("SELECT * REPLACE(UPPER(name) AS name) FROM users");
+    EXPECT_NE(out.find("REPLACE"), std::string::npos);
+    EXPECT_NE(out.find("UPPER"), std::string::npos);
+    EXPECT_NE(out.find("name"), std::string::npos);
+}
+
+// ========== PostgreSQL dialect ==========
+
+TEST_F(PgSQLStarModifiersTest, SelectStarExceptPgSQL) {
+    const char* sql = "SELECT * EXCEPT(id) FROM t1";
+    auto r = parser.parse(sql, strlen(sql));
+    EXPECT_EQ(r.status, ParseResult::OK);
+    EXPECT_EQ(r.stmt_type, StmtType::SELECT);
+}
+
+// ========== Multiple replacements ==========
+
+TEST_F(MySQLStarModifiersTest, MultipleReplacements) {
+    const char* sql = "SELECT * REPLACE(1 + 2 AS x, 'hello' AS y) FROM t1";
+    auto r = parser.parse(sql, strlen(sql));
+    EXPECT_EQ(r.status, ParseResult::OK);
+    EXPECT_EQ(r.stmt_type, StmtType::SELECT);
+    ASSERT_NE(r.ast, nullptr);
+
+    auto* items = find_child(r.ast, NodeType::NODE_SELECT_ITEM_LIST);
+    ASSERT_NE(items, nullptr);
+    auto* item = items->first_child;
+    ASSERT_NE(item, nullptr);
+    auto* replace_node = find_child(item, NodeType::NODE_STAR_REPLACE);
+    ASSERT_NE(replace_node, nullptr);
+
+    // Count REPLACE_ITEM children (skip the first child which is the asterisk)
+    int replace_items = 0;
+    for (const AstNode* c = replace_node->first_child; c; c = c->next_sibling) {
+        if (c->type == NodeType::NODE_REPLACE_ITEM) ++replace_items;
+    }
+    EXPECT_EQ(replace_items, 2);
+}
