Feat: Support regexp

Author: lukaskratzel

native/parser/grammar/VoightLexer.g4

@@ -22,6 +22,8 @@ AND: A N D;
 OR: O R;
 NOT: N O T;
 LIKE: L I K E;
+REGEXP: R E G E X P;
+RLIKE: R L I K E;
 IS: I S;
 NULL_SQL: N U L L;
 TRUE_SQL: T R U E;

native/parser/grammar/VoightParser.g4

@@ -131,6 +131,8 @@ comparisonOperator
     | GT
     | GTE
     | LIKE
+    | REGEXP
+    | RLIKE
     ;
 
 additiveExpression

native/parser/parser_json.cpp

@@ -738,6 +738,12 @@ class NativeAstBuilder {
     if (ctx->LIKE() != nullptr) {
       return "LIKE";
     }
+    if (ctx->REGEXP() != nullptr) {
+      return "REGEXP";
+    }
+    if (ctx->RLIKE() != nullptr) {
+      return "RLIKE";
+    }
     throw ParsingError("Unsupported comparison operator.", span_start(ctx), span_end(ctx));
   }
 

packages/voight/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@voight8/voight",
-    "version": "0.1.8",
+    "version": "0.1.9",
     "description": "TypeScript SQL compiler and policy engine for a restricted SELECT subset of MySQL.",
     "keywords": [
         "compiler",

packages/voight/src/ast/query-ast-schema.ts

@@ -171,6 +171,8 @@ export interface BinaryExpressionNode extends AstNode<"BinaryExpression"> {
         | ">"
         | ">="
         | "LIKE"
+        | "REGEXP"
+        | "RLIKE"
         | "AND"
         | "OR";
     readonly left: ExpressionNode;
@@ -418,7 +420,7 @@ const queryAstScope = scope({
         kind: "'BinaryExpression'",
         span: "SourceSpan",
         operator:
-            "'+' | '-' | '*' | '/' | '%' | '=' | '!=' | '<' | '<=' | '>' | '>=' | 'LIKE' | 'AND' | 'OR'",
+            "'+' | '-' | '*' | '/' | '%' | '=' | '!=' | '<' | '<=' | '>' | '>=' | 'LIKE' | 'REGEXP' | 'RLIKE' | 'AND' | 'OR'",
         left: "ExpressionNode",
         right: "ExpressionNode",
     },

packages/voight/src/compiler/rewriter.ts

@@ -26,6 +26,8 @@ const BINARY_OPERATORS = new Set([
     ">",
     ">=",
     "LIKE",
+    "REGEXP",
+    "RLIKE",
     "AND",
     "OR",
 ]);

packages/voight/src/emitter/index.ts

@@ -361,6 +361,8 @@ function binaryPrecedence(operator: BinaryExpressionNode["operator"]): number {
         case ">":
         case ">=":
         case "LIKE":
+        case "REGEXP":
+        case "RLIKE":
             return 3;
         case "+":
         case "-":
@@ -369,6 +371,9 @@ function binaryPrecedence(operator: BinaryExpressionNode["operator"]): number {
         case "/":
         case "%":
             return 5;
+        default:
+            operator satisfies never;
+            throw new Error(`Unsupported binary operator: ${operator}`);
     }
 }
 

packages/voight/src/policies/supported-operators.ts

@@ -21,6 +21,8 @@ const SUPPORTED_BINARY_OPERATORS = new Set([
     ">",
     ">=",
     "LIKE",
+    "REGEXP",
+    "RLIKE",
     "AND",
     "OR",
 ]);

packages/voight/tests/integration/security/tenant-scoping-regression.test.ts

@@ -53,6 +53,15 @@ describe("FIXED: expression subqueries are now tenant-scoped", () => {
         expect(result.emitted!.sql).toContain("`timeseries`.`tenant_id` = 'tenant-123'");
     });
 
+    test("REGEXP predicate — scoped table still receives tenant predicate", () => {
+        const result = compileTenantScoped(
+            "SELECT metric FROM timeseries WHERE metric REGEXP '^login'",
+        );
+        expect(result.ok).toBe(true);
+        expect(result.emitted!.sql).toContain("`timeseries`.`tenant_id` = 'tenant-123'");
+        expect(result.emitted!.sql).toContain("`timeseries`.`metric` REGEXP '^login'");
+    });
+
     test("IN subquery — tenant predicate injected", () => {
         const result = compileTenantScoped(
             "SELECT id FROM users WHERE id IN (SELECT timeseries.id FROM timeseries)",

packages/voight/tests/integration/security/wildcard-projection-regression.test.ts

@@ -80,6 +80,16 @@ describe("FIXED: wildcard projection respects catalog selectability", () => {
         expect(result.diagnostics[0]?.code).toBe(DiagnosticCode.NonSelectableColumn);
     });
 
+    test("hidden columns are rejected in REGEXP predicates", () => {
+        const operand = compileScoped("SELECT id FROM users WHERE tenant_id REGEXP '^123$'");
+        expect(operand.ok).toBe(false);
+        expect(operand.diagnostics[0]?.code).toBe(DiagnosticCode.NonSelectableColumn);
+
+        const pattern = compileScoped("SELECT id FROM users WHERE name REGEXP tenant_id");
+        expect(pattern.ok).toBe(false);
+        expect(pattern.diagnostics[0]?.code).toBe(DiagnosticCode.NonSelectableColumn);
+    });
+
     test("hidden columns are rejected in BETWEEN predicates", () => {
         const operand = compileScoped("SELECT id FROM users WHERE tenant_id BETWEEN 'a' AND 'z'");
         expect(operand.ok).toBe(false);