remove unnecessary statements and include ipv4 operators

Author: emrberk

.github/workflows/ci.yml

@@ -17,6 +17,8 @@ jobs:
           node-version: 20
           cache: yarn
 
+      - run: corepack enable
+
       - run: yarn
 
       - run: yarn typecheck

src/autocomplete/token-classification.ts

@@ -102,6 +102,11 @@ export const SKIP_TOKENS = new Set([
   "RegexMatch",
   "RegexNotMatch",
   "RegexNotEquals",
+  // IPv4 containment operators
+  "IPv4ContainedBy",
+  "IPv4ContainedByOrEqual",
+  "IPv4Contains",
+  "IPv4ContainsOrEqual",
   // Bitwise operators
   "BitAnd",
   "BitXor",

src/parser/ast.ts

@@ -588,12 +588,7 @@ export interface ShowStatement extends AstNode {
     | "serviceAccounts"
     | "permissions"
     | "serverVersion"
-    | "serverVersionNum"
     | "parameters"
-    | "timeZone"
-    | "transaction"
-    | "transactionIsolationLevel"
-    | "defaultTransactionReadOnly"
   table?: QualifiedName
   name?: QualifiedName
 }

src/parser/cst-types.d.ts

@@ -106,7 +106,6 @@ export type SimpleSelectCstChildren = {
   pivotBody?: PivotBodyCstNode[];
   RParen?: IToken[];
   orderByClause?: OrderByClauseCstNode[];
-  windowDefinitionClause?: WindowDefinitionClauseCstNode[];
   limitClause?: LimitClauseCstNode[];
 };
 
@@ -1318,14 +1317,6 @@ export type ShowStatementCstChildren = {
   Table?: IToken[];
   View?: (IToken)[];
   Materialized?: IToken[];
-  Time?: IToken[];
-  Zone?: IToken[];
-  Transaction?: (IToken)[];
-  Isolation?: IToken[];
-  Level?: IToken[];
-  Default?: IToken[];
-  Identifier?: IToken[];
-  Only?: IToken[];
   User?: IToken[];
   Users?: IToken[];
   Groups?: IToken[];
@@ -1879,10 +1870,23 @@ export interface ConcatExpressionCstNode extends CstNode {
 }
 
 export type ConcatExpressionCstChildren = {
-  additiveExpression: (AdditiveExpressionCstNode)[];
+  ipv4ContainmentExpression: (Ipv4ContainmentExpressionCstNode)[];
   Concat?: IToken[];
 };
 
+export interface Ipv4ContainmentExpressionCstNode extends CstNode {
+  name: "ipv4ContainmentExpression";
+  children: Ipv4ContainmentExpressionCstChildren;
+}
+
+export type Ipv4ContainmentExpressionCstChildren = {
+  additiveExpression: (AdditiveExpressionCstNode)[];
+  IPv4ContainedBy?: IToken[];
+  IPv4ContainedByOrEqual?: IToken[];
+  IPv4Contains?: IToken[];
+  IPv4ContainsOrEqual?: IToken[];
+};
+
 export interface AdditiveExpressionCstNode extends CstNode {
   name: "additiveExpression";
   children: AdditiveExpressionCstChildren;
@@ -2172,22 +2176,6 @@ export type WindowFrameBoundCstChildren = {
   expression?: ExpressionCstNode[];
 };
 
-export interface WindowDefinitionClauseCstNode extends CstNode {
-  name: "windowDefinitionClause";
-  children: WindowDefinitionClauseCstChildren;
-}
-
-export type WindowDefinitionClauseCstChildren = {
-  Window: IToken[];
-  identifier: IdentifierCstNode[];
-  As: IToken[];
-  LParen: IToken[];
-  windowPartitionByClause?: WindowPartitionByClauseCstNode[];
-  orderByClause?: OrderByClauseCstNode[];
-  windowFrameClause?: WindowFrameClauseCstNode[];
-  RParen: IToken[];
-};
-
 export interface LiteralCstNode extends CstNode {
   name: "literal";
   children: LiteralCstChildren;
@@ -2412,6 +2400,7 @@ export interface ICstNodeVisitor<IN, OUT> extends ICstVisitor<IN, OUT> {
   bitXorExpression(children: BitXorExpressionCstChildren, param?: IN): OUT;
   bitAndExpression(children: BitAndExpressionCstChildren, param?: IN): OUT;
   concatExpression(children: ConcatExpressionCstChildren, param?: IN): OUT;
+  ipv4ContainmentExpression(children: Ipv4ContainmentExpressionCstChildren, param?: IN): OUT;
   additiveExpression(children: AdditiveExpressionCstChildren, param?: IN): OUT;
   multiplicativeExpression(children: MultiplicativeExpressionCstChildren, param?: IN): OUT;
   unaryExpression(children: UnaryExpressionCstChildren, param?: IN): OUT;
@@ -2431,7 +2420,6 @@ export interface ICstNodeVisitor<IN, OUT> extends ICstVisitor<IN, OUT> {
   windowPartitionByClause(children: WindowPartitionByClauseCstChildren, param?: IN): OUT;
   windowFrameClause(children: WindowFrameClauseCstChildren, param?: IN): OUT;
   windowFrameBound(children: WindowFrameBoundCstChildren, param?: IN): OUT;
-  windowDefinitionClause(children: WindowDefinitionClauseCstChildren, param?: IN): OUT;
   literal(children: LiteralCstChildren, param?: IN): OUT;
   booleanLiteral(children: BooleanLiteralCstChildren, param?: IN): OUT;
   stringOrIdentifier(children: StringOrIdentifierCstChildren, param?: IN): OUT;

src/parser/lexer.ts

@@ -575,18 +575,48 @@ export const RBracket = createToken({ name: "RBracket", pattern: /\]/ })
 export const Colon = createToken({ name: "Colon", pattern: /:/ })
 export const ColonEquals = createToken({ name: "ColonEquals", pattern: /:=/ })
 
+// IPv4 Containment Operators (longest first to avoid conflicts)
+export const IPv4ContainedByOrEqual = createToken({
+  name: "IPv4ContainedByOrEqual",
+  pattern: /<<=/,
+})
+export const IPv4ContainedBy = createToken({
+  name: "IPv4ContainedBy",
+  pattern: /<</,
+  longer_alt: IPv4ContainedByOrEqual,
+})
+export const IPv4ContainsOrEqual = createToken({
+  name: "IPv4ContainsOrEqual",
+  pattern: />>=/,
+})
+export const IPv4Contains = createToken({
+  name: "IPv4Contains",
+  pattern: />>/,
+  longer_alt: IPv4ContainsOrEqual,
+})
+
 // Comparison Operators (order matters - longer first)
 export const NotEquals = createToken({ name: "NotEquals", pattern: /!=|<>/ })
 export const LessThanOrEqual = createToken({
   name: "LessThanOrEqual",
   pattern: /<=/,
+  longer_alt: IPv4ContainedByOrEqual,
 })
 export const GreaterThanOrEqual = createToken({
   name: "GreaterThanOrEqual",
   pattern: />=/,
+  longer_alt: IPv4ContainsOrEqual,
+})
+export const LessThan = createToken({
+  name: "LessThan",
+  pattern: /</,
+  longer_alt: IPv4ContainedBy,
+})
+export const GreaterThan = createToken({
+  name: "GreaterThan",
+  pattern: />/,
+  longer_alt: IPv4Contains,
 })
-export const LessThan = createToken({ name: "LessThan", pattern: /</ })
-export const GreaterThan = createToken({ name: "GreaterThan", pattern: />/ })
 export const Equals = createToken({ name: "Equals", pattern: /=/ })
 
 // Arithmetic Operators
@@ -731,6 +761,10 @@ export const allTokens: TokenType[] = [
   // Multi-char operators (before single-char)
   DoubleColon,
   ColonEquals,
+  IPv4ContainedByOrEqual,
+  IPv4ContainedBy,
+  IPv4ContainsOrEqual,
+  IPv4Contains,
   NotEquals,
   LessThanOrEqual,
   GreaterThanOrEqual,

src/parser/parser.ts

@@ -219,6 +219,10 @@ import {
   RegexNotEquals,
   Concat,
   DoubleColon,
+  IPv4ContainedBy,
+  IPv4ContainedByOrEqual,
+  IPv4Contains,
+  IPv4ContainsOrEqual,
   Plus,
   Minus,
   Divide,
@@ -251,19 +255,15 @@ import {
   TimestampNs,
   // Other keywords commonly used as identifiers
   Index,
-  Isolation,
   Column,
   Type,
-  Level,
   Offset,
-  Only,
   First,
   Volume,
   Start,
   Current,
   Row,
   User,
-  Default,
   View,
   Tolerance,
   Materialized,
@@ -559,7 +559,6 @@ class QuestDBParser extends CstParser {
         this.CONSUME(RParen)
       })
       this.OPTION6(() => this.SUBRULE(this.orderByClause))
-      this.OPTION8(() => this.SUBRULE(this.windowDefinitionClause))
       this.OPTION7(() => this.SUBRULE(this.limitClause))
     })
   })
@@ -2516,29 +2515,6 @@ class QuestDBParser extends CstParser {
           ])
         },
       },
-      {
-        ALT: () => {
-          this.CONSUME(Time)
-          this.CONSUME(Zone)
-        },
-      },
-      {
-        ALT: () => {
-          this.CONSUME(Transaction)
-          this.OPTION5(() => {
-            this.CONSUME(Isolation)
-            this.CONSUME(Level)
-          })
-        },
-      },
-      {
-        ALT: () => {
-          this.CONSUME(Default)
-          this.CONSUME1(Transaction)
-          this.CONSUME(Identifier) // READ
-          this.CONSUME(Only)
-        },
-      },
       {
         ALT: () => {
           this.CONSUME(User)
@@ -3308,13 +3284,30 @@ class QuestDBParser extends CstParser {
 
   // Precedence 7: || (string concatenation)
   private concatExpression = this.RULE("concatExpression", () => {
-    this.SUBRULE(this.additiveExpression)
+    this.SUBRULE(this.ipv4ContainmentExpression)
     this.MANY(() => {
       this.CONSUME(Concat)
-      this.SUBRULE1(this.additiveExpression)
+      this.SUBRULE1(this.ipv4ContainmentExpression)
     })
   })
 
+  // Precedence 6: <<, <<=, >>, >>= (IPv4 containment)
+  private ipv4ContainmentExpression = this.RULE(
+    "ipv4ContainmentExpression",
+    () => {
+      this.SUBRULE(this.additiveExpression)
+      this.OPTION(() => {
+        this.OR([
+          { ALT: () => this.CONSUME(IPv4ContainedByOrEqual) },
+          { ALT: () => this.CONSUME(IPv4ContainedBy) },
+          { ALT: () => this.CONSUME(IPv4ContainsOrEqual) },
+          { ALT: () => this.CONSUME(IPv4Contains) },
+        ])
+        this.SUBRULE1(this.additiveExpression)
+      })
+    },
+  )
+
   // Precedence 5: +, -
   private additiveExpression = this.RULE("additiveExpression", () => {
     this.SUBRULE(this.multiplicativeExpression)
@@ -3794,18 +3787,6 @@ class QuestDBParser extends CstParser {
     ])
   })
 
-  // Named WINDOW clause: WINDOW w AS (PARTITION BY ...)
-  private windowDefinitionClause = this.RULE("windowDefinitionClause", () => {
-    this.CONSUME(Window)
-    this.SUBRULE(this.identifier)
-    this.CONSUME(As)
-    this.CONSUME(LParen)
-    this.OPTION(() => this.SUBRULE(this.windowPartitionByClause))
-    this.OPTION1(() => this.SUBRULE(this.orderByClause))
-    this.OPTION2(() => this.SUBRULE(this.windowFrameClause))
-    this.CONSUME(RParen)
-  })
-
   // ==========================================================================
   // Basic Elements
   // ==========================================================================

src/parser/toSql.ts

@@ -874,18 +874,8 @@ function showToSql(stmt: AST.ShowStatement): string {
       return `SHOW CREATE MATERIALIZED VIEW ${qualifiedNameToSql(stmt.table!)}`
     case "serverVersion":
       return "SHOW SERVER_VERSION"
-    case "serverVersionNum":
-      return "SHOW SERVER_VERSION_NUM"
     case "parameters":
       return "SHOW PARAMETERS"
-    case "timeZone":
-      return "SHOW TIME ZONE"
-    case "transaction":
-      return "SHOW TRANSACTION"
-    case "transactionIsolationLevel":
-      return "SHOW TRANSACTION ISOLATION LEVEL"
-    case "defaultTransactionReadOnly":
-      return "SHOW DEFAULT TRANSACTION READ ONLY"
     case "user":
       return stmt.name
         ? `SHOW USER ${qualifiedNameToSql(stmt.name)}`