Merge branch 'master' of https://github.com/martin-pabst/SQL-IDE

martin-pabst · martin-pabst · commit 8e45068bf190 · 2023-07-15T07:56:02.000+02:00
diff --git a/src/client/compiler/parser/Parser.ts b/src/client/compiler/parser/Parser.ts
@@ -1355,13 +1355,13 @@ export class Parser {
         let type: SQLBaseType;
 
         if (this.cct.tt == TokenType.keywordEnum) {
+            this.nextToken();
 
             if(this.expect(TokenType.leftBracket, true)){
-                this.nextToken();
     
                 let constants: ConstantNode[] = [];
                 //@ts-ignore
-                while(this.cct.tt != TokenType.rightBracket && !this.isEnd()){
+                while(!this.comesToken(TokenType.rightBracket, true) && !this.isEnd()){
     
                     let constant = this.parseConstant();
                     if(constant != null) constants.push(constant);
diff --git a/src/client/compiler/parser/SQLTypes.ts b/src/client/compiler/parser/SQLTypes.ts
@@ -1,7 +1,7 @@
 import { TokenType } from "../lexer/Token.js";
 
-type CheckFunction = (columnIdentifier: string, parameterValues: number[]) => string;
-type OutputFunction = (value: any, parameterValues: number[]) => string;
+type CheckFunction = (columnIdentifier: string, parameterValues: any[]) => string;
+type OutputFunction = (value: any, parameterValues: any[]) => string;
 
 export abstract class SQLType {
 
@@ -173,6 +173,71 @@ export class SQLBaseType extends SQLType {
 
 }
 
+class SQLNumberEnumType extends SQLBaseType {
+    
+    constructor(public values: string[]){
+        super("enum", [], 
+        (ci, pv) => `check(${ci} in (${(<string[]>pv).join(', ')}))`,
+        (v: string, pv) => v,
+        ["decimal", "integer", "double", "float"]
+        )
+    }
+    
+    getBinaryResultType(operator: TokenType, secondType: SQLType): SQLType {
+        return operator == TokenType.concatenation ? SQLBaseType.getBaseType('double') : null;
+    }
+    
+    getUnaryResultType(operator: TokenType): SQLType {
+        return null;
+    }
+    
+    getBinaryResult(operator: TokenType, value1: any, value2: any) {
+        return value1 + value2;
+    }
+    
+    toString(): string {
+        return "double";
+    }
+    
+    getBaseTypeName(): string {
+        return "enum";
+    }
+
+}
+
+
+class SQLTextEnumType extends SQLBaseType {
+    
+    constructor(public values: string[]){
+        super("enum", [], 
+        (ci, pv) => `check(${ci} in (${(<string[]>pv).map(v => '"' + v + '"').join(', ')}))`,
+        (v: string, pv) => v,
+        ["text", "varchar", "char"]
+        )
+    }
+    
+    getBinaryResultType(operator: TokenType, secondType: SQLType): SQLType {
+        return operator == TokenType.concatenation ? SQLBaseType.getBaseType('text') : null;
+    }
+    
+    getUnaryResultType(operator: TokenType): SQLType {
+        return null;
+    }
+    
+    getBinaryResult(operator: TokenType, value1: any, value2: any) {
+        return value1 + value2;
+    }
+    
+    toString(): string {
+        return "text";
+    }
+    
+    getBaseTypeName(): string {
+        return "enum";
+    }
+
+}
+
 let tens: number[] = [1, 10, 100, 1000, 100000, 100000, 1000000, 10000000, 100000000, 1000000000];
 
 export class SQLDerivedType extends SQLType {
