Fix incorrect StdStmt integration

Author: ox-harris

README.md

@@ -35,7 +35,7 @@ LinkedQL solves **reactivity, relationships, JSON, schemas, embedding, federatio
 
 > [!IMPORTANT]
 > 🚀 **LinkedQL is in active development and evolving daily.** Current status = **alpha**.<br>
-> You’re welcome to experiment, but it’s not yet suited for production workloads.
+> You’re welcome to experiment, but it’s not yet suited for production apps.
 
 ---
 
@@ -79,9 +79,9 @@ import { FlashQL } from '@linked-db/linked-ql/flashql';
 
 const client = new FlashQL();
 
+await client.query(`CREATE TABLE users (id INT PRIMARY KEY, name TEXT)`);
 const result = await client.query(`
-  CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT);
-  INSERT INTO users (name) VALUES ('Ada'), ('Linus');
+  INSERT INTO users (id, name) VALUES (1, 'Ada'), (2, 'Linus');
   SELECT * FROM users;
 `);
 

site/docs.md

@@ -8,7 +8,7 @@ If you're totally new here, you may want to [meet LinkedQL](/overview).
 
 > [!IMPORTANT]
 > 🚀 **LinkedQL is in active development and evolving daily.** Current status = **alpha**.<br>
-> You’re welcome to experiment, but it’s not yet suited for production workloads.
+> You’re welcome to experiment, but it’s not yet suited for production apps.
 
 ## Installation
 
@@ -34,9 +34,9 @@ import { FlashQL } from '@linked-db/linked-ql/flashql';
 
 const client = new FlashQL();
 
+await client.query(`CREATE TABLE users (id INT PRIMARY KEY, name TEXT)`);
 const result = await client.query(`
-  CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT);
-  INSERT INTO users (name) VALUES ('Ada'), ('Linus');
+  INSERT INTO users (id, name) VALUES (1, 'Ada'), (2, 'Linus');
   SELECT * FROM users;
 `);
 

src/entry/abstracts/AbstractSQLClient.js

@@ -213,7 +213,7 @@ export class AbstractSQLClient extends AbstractClient {
                 };
 
                 break;
-            
+
             default: throw new Error(`Invalid query input`);
         }
 
@@ -270,13 +270,22 @@ export class AbstractSQLClient extends AbstractClient {
         // Parsing...
         if (!(query instanceof AbstractNode)) {
             query = await this.parse(query, options);
-        } else if (!(query instanceof registry.Script) && !(query instanceof AbstractStmt)) {
+        } else if (!(query instanceof registry.Script)
+            && !(query instanceof AbstractStmt)
+            && !(query instanceof registry.MYSetStmt)
+            && !(query instanceof registry.PGSetStmt)) {
             throw new TypeError('query must be a string or an instance of Script | AbstractStmt');
         }
         if (query instanceof registry.Script && query.length === 1) {
             query = query.entries()[0];
         }
 
+        // Return if query is a set statement or a standard statement
+        if (query instanceof registry.MYSetStmt
+            || query instanceof registry.PGSetStmt
+            || query instanceof registry.StdStmt
+        ) return query;
+
         // Determine by heuristics if desugaring needed
         if ((query instanceof registry.DDLStmt && !query.returningClause?.()) // Desugaring not applicable
             || query.originSchemas?.()?.length // Desugaring already done
@@ -286,6 +295,10 @@ export class AbstractSQLClient extends AbstractClient {
         const relationSelector = {};
         let anyFound = false;
         query.walkTree((v, k, scope) => {
+            if (v instanceof registry.MYSetStmt
+                || v instanceof registry.PGSetStmt
+                || v instanceof registry.StdStmt
+            ) return;
             if (v instanceof registry.DDLStmt
                 && !v.returningClause?.()) return;
             if (v instanceof registry.CTEItem) {

src/flashql/QueryEngine.js

@@ -83,6 +83,8 @@ export class QueryEngine extends SimpleEmitter {
         let returnValue;
         for (let stmtNode of (scriptNode instanceof registry.Script && scriptNode || [scriptNode])) {
             switch (stmtNode.NODE_NAME) {
+                // CONFIG
+                case 'PG_SET_STMT': returnValue = await this.#evaluatePG_SET_STMT(stmtNode, queryCtx); break;
                 // DDL
                 case 'CREATE_SCHEMA_STMT': returnValue = await this.#evaluateCREATE_SCHEMA_STMT(stmtNode, queryCtx); break;
                 case 'ALTER_SCHEMA_STMT': returnValue = await this.#evaluateALTER_SCHEMA_STMT(stmtNode, queryCtx); break;
@@ -101,12 +103,28 @@ export class QueryEngine extends SimpleEmitter {
                 case 'BASIC_SELECT_STMT':
                 case 'COMPLETE_SELECT_STMT': returnValue = await this.#evaluateSELECT_STMT(stmtNode, queryCtx); break;
                 case 'COMPOSITE_SELECT_STMT': returnValue = await this.#evaluateCOMPOSITE_SELECT_STMT(stmtNode, queryCtx); break;
+                // STD_STMT
+                case 'STD_STMT': console.error(`Not supported yet in the in-memory StorageEngine: ${stmtNode.stringify()}`); break;
+                // Throw
                 default: throw new Error(`Unknown statement type: ${stmtNode.NODE_NAME}`);
             }
         }
         return returnValue;
     }
 
+    // -------- CONFIG
+
+    async #evaluatePG_SET_STMT(stmtNode, queryCtx) {
+        const scopeKW = stmtNode.scopeKW();
+        const left = stmtNode.left()?.toLowerCase();
+        const right = stmtNode.right();
+        if (left === 'search_path') {
+            const searchPath = right.map((r) => r.value());
+            this.#storageEngine.setSearchPath(...searchPath);
+            return true;
+        }
+    }
+
     // -------- DDL
 
     async #evaluateCREATE_SCHEMA_STMT(stmtNode, queryCtx) {

src/flashql/StorageEngine.js

@@ -4,28 +4,36 @@ import { StorageNamespace } from './StorageNamespace.js';
 
 export class StorageEngine extends SimpleEmitter {
 
-    #defaultNamespace;
+    #searchPath;
     #options;
 
     #catalog = new Map;
     #init;
 
-    get defaultNamespace() { return this.#defaultNamespace; }
+    get defaultNamespace() { return this.#searchPath[0]; }
     get options() { return this.#options; }
 
     constructor({
-        defaultNamespace = 'public',
+        searchPath = ['public'],
         ...options
     } = {}) {
         super();
-        this.#defaultNamespace = defaultNamespace;
+        this.#searchPath = [].concat(searchPath || []);
         this.#options = options;
 
-        if (defaultNamespace) {
-            this.#init = this.createNamespace(defaultNamespace, { ifNotExists: true });
+        if (this.defaultNamespace) {
+            this.#init = this.createNamespace(this.defaultNamespace, { ifNotExists: true });
         }
     }
 
+    async setSearchPath(...searchPath) {
+        this.#searchPath = searchPath;
+    }
+
+    async getSearchPath() {
+        return this.#searchPath.slice();
+    }
+
     async startTransaction(txIdPrefix = '~tx') {
         const events = new Map;
         const txId = `${txIdPrefix}:${(0 | Math.random() * 9e6).toString(36)}`;

src/flashql/TableStorage.js

@@ -101,7 +101,7 @@ export class TableStorage extends SimpleEmitter {
             for (const colSchema of this.#columns) {
                 const colName = colSchema.name().value();
 
-                const autoIncr = colSchema.identityConstraint() || colSchema.autoIncrementConstraint();
+                const autoIncr = colSchema.identityConstraint() || colSchema.dataType().value() === 'SERIAL' || colSchema.autoIncrementConstraint();
                 const isPKey = this.#keyColumns.includes(colName);
 
                 let v = row[colName];

src/lang/SchemaInference.js

@@ -4,7 +4,9 @@ import { matchRelationSelector, normalizeRelationSelectorArg } from '../entry/ab
 export class SchemaInference {
 
     #searchPath = ['public'];
-    get searchPath() { return this.#searchPath; }
+    get searchPath() {
+        return this.#searchPath;
+    }
 
     #driver;
     #queryHistory = new Map;

src/lang/Script.js

@@ -14,11 +14,13 @@ export class Script extends AbstractNodeList {
             'UpdateStmt',
             'DeleteStmt',
             'MYSetStmt',
+            'PGSetStmt',
             'CTE',
             'CreateSchemaStmt',
             'DropSchemaStmt',
             'CreateTableStmt',
             'DropTableStmt',
+            'StdStmt',
         ];
     }
 
@@ -30,10 +32,6 @@ export class Script extends AbstractNodeList {
     /* API */
 
     static async parse(input, options = {}) {
-        if (options.supportStdStmt) {
-            const std = await StdStmt.parse(input);
-            if (std) return new this({ entries: [std] });
-        }
         const tokenStream = await this.toStream(input, options);
         const result = await super.parse(tokenStream, options);
         if (!tokenStream.done && tokenStream.current()) {
@@ -44,5 +42,13 @@ export class Script extends AbstractNodeList {
         return result;
     }
 
+	static async _parseFromRules(tokenStream, syntaxRules, { left, minPrecedence, trail, ...options }, resultAST = {}) {
+        let rulesArray;
+        if (!options.supportStdStmt && (rulesArray = [].concat(syntaxRules)).length === 1 && Array.isArray(rulesArray[0].type) && rulesArray[0].type.includes('StdStmt')) {
+            syntaxRules = { ...rulesArray[0], type: rulesArray[0].type.filter((r) => r !== 'StdStmt') };
+        }
+		return super._parseFromRules(tokenStream, syntaxRules, { left, minPrecedence, trail, ...options }, resultAST);
+	}
+
     stringify(options = {}) { return `${super.stringify(options)};`; }
 }

src/lang/StdStmt.js

@@ -1,4 +1,5 @@
 import { AbstractStmt } from './abstracts/AbstractStmt.js';
+import { TokenStream } from './TokenStream.js';
 
 export class StdStmt extends AbstractStmt {
 
@@ -25,8 +26,37 @@ export class StdStmt extends AbstractStmt {
     sql() { return this._get('sql'); }
 
     static async parse(sql, options = {}) {
-        if (typeof sql !== 'string'
-            || /^(\((\s+)?)?(WITH|TABLE|SELECT|DELETE|INSERT|UPDATE|UPSERT|CREATE|DROP)\s+/i.test(sql.trimStart())) return;
+        const test = (sql) => (typeof sql === 'string'
+            && !/^(\((\s+)?)?(WITH|TABLE|SELECT|DELETE|INSERT|UPDATE|UPSERT|CREATE|DROP|SET)\s+/i.test(sql.trimStart()));
+        
+        if (sql instanceof TokenStream) {
+            const _sql = [];
+
+            if (sql.current()) {
+                if (!test(sql.current().value)) return;
+                _sql.push(sql.current().value);
+            }
+
+            await (async function render(tokenStream) {
+                for await (const tok of tokenStream) {
+                    if (tok.spaceBefore) _sql.push(tok.spaceBefore);
+                    if (tok.value instanceof TokenStream) {
+                        const tag = tok.type === 'bracket_block' ? ['{', '}'] : (
+                            tok.type === 'bracket_block' ? ['[', ']'] : ['(', ')']
+                        );
+                        _sql.push(tag[0]);
+                        await render(tok.value);
+                        _sql.push(tag[1]);
+                    } else _sql.push(tok.value);
+                    if (tok.value === ';') break;
+                }
+            })(sql);
+
+            sql = _sql.join('');
+        }
+
+        if (!sql || !test(sql)) return;
+
         return new this({ sql }, { ...options });
     }
 

src/lang/ddl/DDLStmt.js

@@ -6,4 +6,13 @@ export class DDLStmt extends AbstractStmt {
     /* SYNTAX RULES */
 
     static get syntaxRules() { return { type: ['CreateSchemaStmt', 'DropSchemaStmt', 'CreateTableStmt', 'DropTableStmt'] }; }
+
+    /** API */
+    
+    jsonfy({ deSugar, ...options } = {}, transformer = null, schemaInference = null) {
+        if (this.returningClause?.()) {
+            options = { deSugar, ...options };
+        }
+        return super.jsonfy(options, transformer, schemaInference);
+    }
 }