@bytebase/dbhub 0.9.0 → 0.10.0

package/README.md

@@ -24,6 +24,8 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |                  |    |              |    |                  |
  |  Cursor          +--->+    DBHub     +--->+    SQL Server    |
  |                  |    |              |    |                  |
+ |  Other Clients   +--->+              +--->+    SQLite        |
+ |                  |    |              |    |                  |
  |                  |    |              +--->+    MySQL         |
  |                  |    |              |    |                  |
  |                  |    |              +--->+    MariaDB       |
@@ -42,27 +44,27 @@ https://demo.dbhub.ai/message connects a [sample employee database](https://gith
 
 ### Database Resources
 
-| Resource Name               | URI Format                                             | PostgreSQL | MySQL | MariaDB | SQL Server |
-| --------------------------- | ------------------------------------------------------ | :--------: | :---: | :-----: | :--------: |
-| schemas                     | `db://schemas`                                         |     ✅     |  ✅   |   ✅    |     ✅     |
-| tables_in_schema            | `db://schemas/{schemaName}/tables`                     |     ✅     |  ✅   |   ✅    |     ✅     |
-| table_structure_in_schema   | `db://schemas/{schemaName}/tables/{tableName}`         |     ✅     |  ✅   |   ✅    |     ✅     |
-| indexes_in_table            | `db://schemas/{schemaName}/tables/{tableName}/indexes` |     ✅     |  ✅   |   ✅    |     ✅     |
-| procedures_in_schema        | `db://schemas/{schemaName}/procedures`                 |     ✅     |  ✅   |   ✅    |     ✅     |
-| procedure_details_in_schema | `db://schemas/{schemaName}/procedures/{procedureName}` |     ✅     |  ✅   |   ✅    |     ✅     |
+| Resource Name               | URI Format                                             | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| --------------------------- | ------------------------------------------------------ | :--------: | :---: | :-----: | :--------: | :----: |
+| schemas                     | `db://schemas`                                         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| tables_in_schema            | `db://schemas/{schemaName}/tables`                     |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| table_structure_in_schema   | `db://schemas/{schemaName}/tables/{tableName}`         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| indexes_in_table            | `db://schemas/{schemaName}/tables/{tableName}/indexes` |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| procedures_in_schema        | `db://schemas/{schemaName}/procedures`                 |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
+| procedure_details_in_schema | `db://schemas/{schemaName}/procedures/{procedureName}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
 
 ### Database Tools
 
-| Tool        | Command Name  | Description                                                         | PostgreSQL | MySQL | MariaDB | SQL Server |
-| ----------- | ------------- | ------------------------------------------------------------------- | :--------: | :---: | :-----: | :--------: |
-| Execute SQL | `execute_sql` | Execute single or multiple SQL statements (separated by semicolons) |     ✅     |  ✅   |   ✅    |     ✅     |
+| Tool        | Command Name  | Description                                                         | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| ----------- | ------------- | ------------------------------------------------------------------- | :--------: | :---: | :-----: | :--------: | ------ |
+| Execute SQL | `execute_sql` | Execute single or multiple SQL statements (separated by semicolons) |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
 
 ### Prompt Capabilities
 
-| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server |
-| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: |
-| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     |
-| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     |
+| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ |
+| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
 
 ## Installation
 
@@ -79,6 +81,16 @@ docker run --rm --init \
    --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
 ```
 
+```bash
+# Demo mode with sample employee database
+docker run --rm --init \
+   --name dbhub \
+   --publish 8080:8080 \
+   bytebase/dbhub \
+   --transport http \
+   --port 8080 \
+   --demo
+```
 
 
 ### NPM
@@ -88,6 +100,12 @@ docker run --rm --init \
 npx @bytebase/dbhub --transport http --port 8080 --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
 ```
 
+```bash
+# Demo mode with sample employee database
+npx @bytebase/dbhub --transport http --port 8080 --demo
+```
+
+> Note: The demo mode includes a bundled SQLite sample "employee" database with tables for employees, departments, salaries, and more.
 
 ### Claude Desktop
 
@@ -124,6 +142,10 @@ npx @bytebase/dbhub --transport http --port 8080 --dsn "postgres://user:password
         "postgres://user:password@localhost:5432/dbname?sslmode=disable"
       ]
     },
+    "dbhub-demo": {
+      "command": "npx",
+      "args": ["-y", "@bytebase/dbhub", "--transport", "stdio", "--demo"]
+    }
   }
 }
 ```
@@ -149,6 +171,7 @@ You can specify the SSL mode using the `sslmode` parameter in your DSN string:
 | MySQL      |        ✅         |        ✅         |    Certificate verification    |
 | MariaDB    |        ✅         |        ✅         |    Certificate verification    |
 | SQL Server |        ✅         |        ✅         |    Certificate verification    |
+| SQLite     |        ❌         |        ❌         |        N/A (file-based)        |
 
 **SSL Mode Options:**
 
@@ -185,6 +208,12 @@ This provides an additional layer of security when connecting to production data
 
 ### Configure your database connection
 
+You can use DBHub in demo mode with a sample employee database for testing:
+
+```bash
+npx @bytebase/dbhub  --demo
+```
+
 > [!WARNING]
 > If your user/password contains special characters, you need to escape them first. (e.g. `pass#word` should be escaped as `pass%23word`)
 
@@ -221,6 +250,7 @@ DBHub supports the following database connection string formats:
 | MariaDB    | `mariadb://[user]:[password]@[host]:[port]/[database]`    | `mariadb://user:password@localhost:3306/dbname?sslmode=disable`                                                |
 | PostgreSQL | `postgres://[user]:[password]@[host]:[port]/[database]`   | `postgres://user:password@localhost:5432/dbname?sslmode=disable`                                               |
 | SQL Server | `sqlserver://[user]:[password]@[host]:[port]/[database]`  | `sqlserver://user:password@localhost:1433/dbname?sslmode=disable`                                              |
+| SQLite     | `sqlite:///[path/to/file]` or `sqlite:///:memory:`        | `sqlite:///path/to/database.db`, `sqlite:C:/Users/YourName/data/database.db (windows)` or `sqlite:///:memory:` |
 
 
 #### SQL Server
@@ -246,13 +276,15 @@ Extra query parameters:
 
 ### Command line options
 
-| Option    | Environment Variable | Description                                                      | Default  |
-| --------- | -------------------- | ---------------------------------------------------------------- | -------- |
-| dsn       | `DSN`                | Database connection string                                       | Required |
-| transport | `TRANSPORT`          | Transport mode: `stdio` or `http`                                | `stdio`  |
-| port      | `PORT`               | HTTP server port (only applicable when using `--transport=http`) | `8080`   |
-| readonly  | `READONLY`           | Restrict SQL execution to read-only operations                   | `false`  |
+| Option    | Environment Variable | Description                                                      | Default                      |
+| --------- | -------------------- | ---------------------------------------------------------------- | ---------------------------- |
+| dsn       | `DSN`                | Database connection string                                       | Required if not in demo mode |
+| transport | `TRANSPORT`          | Transport mode: `stdio` or `http`                                | `stdio`                      |
+| port      | `PORT`               | HTTP server port (only applicable when using `--transport=http`) | `8080`                       |
+| readonly  | `READONLY`           | Restrict SQL execution to read-only operations                   | `false`                      |
+| demo      | N/A                  | Run in demo mode with sample employee database                   | `false`                      |
 
+The demo mode uses an in-memory SQLite database loaded with the [sample employee database](https://github.com/bytebase/dbhub/tree/main/resources/employee-sqlite) that includes tables for employees, departments, titles, salaries, department employees, and department managers. The sample database includes SQL scripts for table creation, data loading, and testing.
 
 ## Development
 
@@ -310,6 +342,8 @@ pnpm test src/connectors/__tests__/mysql.integration.test.ts
 pnpm test src/connectors/__tests__/mariadb.integration.test.ts
 # Run only SQL Server integration tests
 pnpm test src/connectors/__tests__/sqlserver.integration.test.ts
+# Run only SQLite integration tests
+pnpm test src/connectors/__tests__/sqlite.integration.test.ts
 # Run JSON RPC integration tests
 pnpm test src/__tests__/json-rpc-integration.test.ts
 ```

package/dist/index.js

@@ -159,6 +159,9 @@ function obfuscateDSNPassword(dsn) {
       return dsn;
     }
     const protocol = protocolMatch[1];
+    if (protocol === "sqlite") {
+      return dsn;
+    }
     const protocolPart = dsn.split("://")[1];
     if (!protocolPart) {
       return dsn;
@@ -876,6 +879,246 @@ var SQLServerConnector = class {
 var sqlServerConnector = new SQLServerConnector();
 ConnectorRegistry.register(sqlServerConnector);
 
+// src/connectors/sqlite/index.ts
+import Database from "better-sqlite3";
+var SQLiteDSNParser = class {
+  async parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid SQLite DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(dsn);
+      let dbPath;
+      if (url.hostname === "" && url.pathname === "/:memory:") {
+        dbPath = ":memory:";
+      } else {
+        if (url.pathname.startsWith("//")) {
+          dbPath = url.pathname.substring(2);
+        } else {
+          dbPath = url.pathname;
+        }
+      }
+      return { dbPath };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse SQLite DSN: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSampleDSN() {
+    return "sqlite:///path/to/database.db";
+  }
+  isValidDSN(dsn) {
+    try {
+      return dsn.startsWith("sqlite://");
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var SQLiteConnector = class {
+  constructor() {
+    this.id = "sqlite";
+    this.name = "SQLite";
+    this.dsnParser = new SQLiteDSNParser();
+    this.db = null;
+    this.dbPath = ":memory:";
+  }
+  // Default to in-memory database
+  async connect(dsn, initScript) {
+    const config = await this.dsnParser.parse(dsn);
+    this.dbPath = config.dbPath;
+    try {
+      this.db = new Database(this.dbPath);
+      console.error("Successfully connected to SQLite database");
+      if (initScript) {
+        this.db.exec(initScript);
+        console.error("Successfully initialized database with script");
+      }
+    } catch (error) {
+      console.error("Failed to connect to SQLite database:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.db) {
+      try {
+        this.db.close();
+        this.db = null;
+      } catch (error) {
+        throw error;
+      }
+    }
+    return Promise.resolve();
+  }
+  async getSchemas() {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return ["main"];
+  }
+  async getTables(schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const rows = this.db.prepare(
+        `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `
+      ).all();
+      return rows.map((row) => row.name);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async tableExists(tableName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const row = this.db.prepare(
+        `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name = ?
+      `
+      ).get(tableName);
+      return !!row;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const indexInfoRows = this.db.prepare(
+        `
+        SELECT 
+          name as index_name,
+          0 as is_unique
+        FROM sqlite_master 
+        WHERE type = 'index' 
+        AND tbl_name = ?
+      `
+      ).all(tableName);
+      const indexListRows = this.db.prepare(`PRAGMA index_list(${tableName})`).all();
+      const indexUniqueMap = /* @__PURE__ */ new Map();
+      for (const indexListRow of indexListRows) {
+        indexUniqueMap.set(indexListRow.name, indexListRow.unique === 1);
+      }
+      const tableInfo = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
+      const results = [];
+      for (const indexInfo of indexInfoRows) {
+        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${indexInfo.index_name})`).all();
+        const columnNames = indexDetailRows.map((row) => row.name);
+        results.push({
+          index_name: indexInfo.index_name,
+          column_names: columnNames,
+          is_unique: indexUniqueMap.get(indexInfo.index_name) || false,
+          is_primary: false
+        });
+      }
+      if (pkColumns.length > 0) {
+        results.push({
+          index_name: "PRIMARY",
+          column_names: pkColumns,
+          is_unique: true,
+          is_primary: true
+        });
+      }
+      return results;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const rows = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const columns = rows.map((row) => ({
+        column_name: row.name,
+        data_type: row.type,
+        // In SQLite, primary key columns are automatically NOT NULL even if notnull=0
+        is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
+        column_default: row.dflt_value
+      }));
+      return columns;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getStoredProcedures(schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return [];
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    throw new Error(
+      "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
+    );
+  }
+  async executeSQL(sql2) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+      if (statements.length === 1) {
+        const trimmedStatement = statements[0].toLowerCase().trim();
+        const isReadStatement = trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"));
+        if (isReadStatement) {
+          const rows = this.db.prepare(statements[0]).all();
+          return { rows };
+        } else {
+          this.db.prepare(statements[0]).run();
+          return { rows: [] };
+        }
+      } else {
+        const readStatements = [];
+        const writeStatements = [];
+        for (const statement of statements) {
+          const trimmedStatement = statement.toLowerCase().trim();
+          if (trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"))) {
+            readStatements.push(statement);
+          } else {
+            writeStatements.push(statement);
+          }
+        }
+        if (writeStatements.length > 0) {
+          this.db.exec(writeStatements.join("; "));
+        }
+        let allRows = [];
+        for (const statement of readStatements) {
+          const result = this.db.prepare(statement).all();
+          allRows.push(...result);
+        }
+        return { rows: allRows };
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+};
+var sqliteConnector = new SQLiteConnector();
+ConnectorRegistry.register(sqliteConnector);
+
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";
 var MySQLDSNParser = class {
@@ -1637,9 +1880,9 @@ import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import express from "express";
-import path2 from "path";
+import path3 from "path";
 import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/connectors/manager.ts
 var managerInstance = null;
@@ -1773,6 +2016,10 @@ function loadEnvFiles() {
   }
   return null;
 }
+function isDemoMode() {
+  const args = parseCommandLineArgs();
+  return args.demo === "true";
+}
 function isReadOnlyMode() {
   const args = parseCommandLineArgs();
   if (args.readonly !== void 0) {
@@ -1785,6 +2032,13 @@ function isReadOnlyMode() {
 }
 function resolveDSN() {
   const args = parseCommandLineArgs();
+  if (isDemoMode()) {
+    return {
+      dsn: "sqlite:///:memory:",
+      source: "demo mode",
+      isDemo: true
+    };
+  }
   if (args.dsn) {
     return { dsn: args.dsn, source: "command line argument" };
   }
@@ -1833,6 +2087,45 @@ function redactDSN(dsn) {
   }
 }
 
+// src/config/demo-loader.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+var DEMO_DATA_DIR;
+var projectRootPath = path2.join(__dirname2, "..", "..", "..");
+var projectResourcesPath = path2.join(projectRootPath, "resources", "employee-sqlite");
+var distPath = path2.join(__dirname2, "resources", "employee-sqlite");
+if (fs2.existsSync(projectResourcesPath)) {
+  DEMO_DATA_DIR = projectResourcesPath;
+} else if (fs2.existsSync(distPath)) {
+  DEMO_DATA_DIR = distPath;
+} else {
+  DEMO_DATA_DIR = path2.join(process.cwd(), "resources", "employee-sqlite");
+  if (!fs2.existsSync(DEMO_DATA_DIR)) {
+    throw new Error(`Could not find employee-sqlite resources in any of the expected locations: 
+      - ${projectResourcesPath}
+      - ${distPath}
+      - ${DEMO_DATA_DIR}`);
+  }
+}
+function loadSqlFile(fileName) {
+  const filePath = path2.join(DEMO_DATA_DIR, fileName);
+  return fs2.readFileSync(filePath, "utf8");
+}
+function getSqliteInMemorySetupSql() {
+  let sql2 = loadSqlFile("employee.sql");
+  const readRegex = /\.read\s+([a-zA-Z0-9_]+\.sql)/g;
+  let match;
+  while ((match = readRegex.exec(sql2)) !== null) {
+    const includePath = match[1];
+    const includeContent = loadSqlFile(includePath);
+    sql2 = sql2.replace(match[0], includeContent);
+  }
+  return sql2;
+}
+
 // src/resources/index.ts
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
@@ -2185,6 +2478,7 @@ var allowedKeywords = {
   postgres: ["select", "with", "explain", "analyze", "show"],
   mysql: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
   mariadb: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
+  sqlite: ["select", "with", "explain", "analyze", "pragma"],
   sqlserver: ["select", "with", "explain", "showplan"]
 };
 
@@ -2252,6 +2546,9 @@ async function sqlGeneratorPromptHandler({
       case "postgres":
         sqlDialect = "postgres";
         break;
+      case "sqlite":
+        sqlDialect = "sqlite";
+        break;
       case "mysql":
         sqlDialect = "mysql";
         break;
@@ -2312,6 +2609,11 @@ ${accessibleSchemas.map(
           "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
           "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
         ],
+        sqlite: [
+          "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
+          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+        ],
         mysql: [
           "SELECT * FROM users WHERE created_at > NOW() - INTERVAL 1 DAY",
           "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
@@ -2643,9 +2945,9 @@ function registerPrompts(server) {
 }
 
 // src/server.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var packageJsonPath = path2.join(__dirname2, "..", "package.json");
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path3.dirname(__filename3);
+var packageJsonPath = path3.join(__dirname3, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
@@ -2672,7 +2974,8 @@ async function main() {
 ERROR: Database connection string (DSN) is required.
 Please provide the DSN in one of these ways (in order of priority):
 
-1. Command line argument: --dsn="your-connection-string"
+1. Use demo mode: --demo (uses in-memory SQLite with sample employee database)
+2. Command line argument: --dsn="your-connection-string"
 3. Environment variable: export DSN="your-connection-string"
 4. .env file: DSN=your-connection-string
 
@@ -2696,13 +2999,22 @@ See documentation for more details on configuring database connections.
     const connectorManager = new ConnectorManager();
     console.error(`Connecting with DSN: ${redactDSN(dsnData.dsn)}`);
     console.error(`DSN source: ${dsnData.source}`);
-    await connectorManager.connectWithDSN(dsnData.dsn);
+    if (dsnData.isDemo) {
+      const initScript = getSqliteInMemorySetupSql();
+      await connectorManager.connectWithDSN(dsnData.dsn, initScript);
+    } else {
+      await connectorManager.connectWithDSN(dsnData.dsn);
+    }
     const transportData = resolveTransport();
     console.error(`Using transport: ${transportData.type}`);
     console.error(`Transport source: ${transportData.source}`);
     const readonly = isReadOnlyMode();
     const activeModes = [];
     const modeDescriptions = [];
+    if (dsnData.isDemo) {
+      activeModes.push("DEMO");
+      modeDescriptions.push("using sample employee database");
+    }
     if (readonly) {
       activeModes.push("READ-ONLY");
       modeDescriptions.push("only read only queries allowed");

package/dist/resources/employee-sqlite/employee.sql

@@ -0,0 +1,117 @@
+--  Sample employee database 
+--  See changelog table for details
+--  Copyright (C) 2007,2008, MySQL AB
+--  
+--  Original data created by Fusheng Wang and Carlo Zaniolo
+--  http://www.cs.aau.dk/TimeCenter/software.htm
+--  http://www.cs.aau.dk/TimeCenter/Data/employeeTemporalDataSet.zip
+-- 
+--  Current schema by Giuseppe Maxia 
+--  Data conversion from XML to relational by Patrick Crews
+--  SQLite adaptation by Claude Code
+-- 
+-- This work is licensed under the 
+-- Creative Commons Attribution-Share Alike 3.0 Unported License. 
+-- To view a copy of this license, visit 
+-- http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to 
+-- Creative Commons, 171 Second Street, Suite 300, San Francisco, 
+-- California, 94105, USA.
+-- 
+--  DISCLAIMER
+--  To the best of our knowledge, this data is fabricated, and
+--  it does not correspond to real people. 
+--  Any similarity to existing people is purely coincidental.
+-- 
+
+PRAGMA foreign_keys = ON;
+
+SELECT 'CREATING DATABASE STRUCTURE' as 'INFO';
+
+DROP TABLE IF EXISTS dept_emp;
+DROP TABLE IF EXISTS dept_manager;
+DROP TABLE IF EXISTS title;
+DROP TABLE IF EXISTS salary;
+DROP TABLE IF EXISTS employee;
+DROP TABLE IF EXISTS department;
+DROP VIEW IF EXISTS dept_emp_latest_date;
+DROP VIEW IF EXISTS current_dept_emp;
+
+CREATE TABLE employee (
+    emp_no      INTEGER         NOT NULL,
+    birth_date  DATE            NOT NULL,
+    first_name  TEXT            NOT NULL,
+    last_name   TEXT            NOT NULL,
+    gender      TEXT            NOT NULL CHECK (gender IN ('M','F')),
+    hire_date   DATE            NOT NULL,
+    PRIMARY KEY (emp_no)
+);
+
+CREATE TABLE department (
+    dept_no     TEXT            NOT NULL,
+    dept_name   TEXT            NOT NULL,
+    PRIMARY KEY (dept_no),
+    UNIQUE      (dept_name)
+);
+
+CREATE TABLE dept_manager (
+   emp_no       INTEGER         NOT NULL,
+   dept_no      TEXT            NOT NULL,
+   from_date    DATE            NOT NULL,
+   to_date      DATE            NOT NULL,
+   FOREIGN KEY (emp_no)  REFERENCES employee (emp_no)    ON DELETE CASCADE,
+   FOREIGN KEY (dept_no) REFERENCES department (dept_no) ON DELETE CASCADE,
+   PRIMARY KEY (emp_no,dept_no)
+); 
+
+CREATE TABLE dept_emp (
+    emp_no      INTEGER         NOT NULL,
+    dept_no     TEXT            NOT NULL,
+    from_date   DATE            NOT NULL,
+    to_date     DATE            NOT NULL,
+    FOREIGN KEY (emp_no)  REFERENCES employee (emp_no)   ON DELETE CASCADE,
+    FOREIGN KEY (dept_no) REFERENCES department (dept_no) ON DELETE CASCADE,
+    PRIMARY KEY (emp_no,dept_no)
+);
+
+CREATE TABLE title (
+    emp_no      INTEGER         NOT NULL,
+    title       TEXT            NOT NULL,
+    from_date   DATE            NOT NULL,
+    to_date     DATE,
+    FOREIGN KEY (emp_no) REFERENCES employee (emp_no) ON DELETE CASCADE,
+    PRIMARY KEY (emp_no,title,from_date)
+);
+
+CREATE TABLE salary (
+    emp_no      INTEGER         NOT NULL,
+    amount      INTEGER         NOT NULL,
+    from_date   DATE            NOT NULL,
+    to_date     DATE            NOT NULL,
+    FOREIGN KEY (emp_no) REFERENCES employee (emp_no) ON DELETE CASCADE,
+    PRIMARY KEY (emp_no,from_date)
+);
+
+CREATE VIEW dept_emp_latest_date AS
+    SELECT emp_no, MAX(from_date) AS from_date, MAX(to_date) AS to_date
+    FROM dept_emp
+    GROUP BY emp_no;
+
+-- shows only the current department for each employee
+CREATE VIEW current_dept_emp AS
+    SELECT l.emp_no, dept_no, l.from_date, l.to_date
+    FROM dept_emp d
+        INNER JOIN dept_emp_latest_date l
+        ON d.emp_no=l.emp_no AND d.from_date=l.from_date AND l.to_date = d.to_date;
+
+SELECT 'LOADING department' as 'INFO';
+.read load_department.sql
+SELECT 'LOADING employee' as 'INFO';
+.read load_employee.sql
+SELECT 'LOADING dept_emp' as 'INFO';
+.read load_dept_emp.sql
+SELECT 'LOADING dept_manager' as 'INFO';
+.read load_dept_manager.sql
+SELECT 'LOADING title' as 'INFO';
+.read load_title.sql
+SELECT 'LOADING salary' as 'INFO';
+.read load_salary1.sql