add database name if exists on DB client (#2992)

<!-- CURSOR_SUMMARY -->
> [!NOTE]
> Adds database-qualified table handling across Python QueryClient and
TypeScript sql tag, with new tests; updates backward-compat E2E to use
latest CLI.
> 
> - **Python (moose_lib)**
> - **QueryClient.execute**: When interpolating `OlapTable` with a
`database`, generates two identifier params (`{pN: Identifier}.{pN+1:
Identifier}`) and updates preview formatting to `database.table`.
>   - Corrects parameter indexing and whitespace in function signature.
> - **TypeScript (ts-moose-lib)**
> - **sqlHelpers.Sql**: Renders `OlapTable` with `config.database` as ``
`database`.`table` ``; falls back to `` `table` `` when no database.
> - **Tests**
> - Python: Add coverage for tables with/without `database` ensuring
two-identifier parameterization.
> - TypeScript: Add tests for database-qualified tables in `sql`
template and an extra integration case.
> - **E2E**
> - Backward-compat test now uses `@514labs/moose-cli@latest` and
updates log messages.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
7de28c3. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: phiSgr

apps/framework-cli-e2e/test/backward-compatibility.test.ts

@@ -305,7 +305,7 @@ describe("Backward Compatibility Tests", function () {
               TEST_AWS_SECRET_ACCESS_KEY: "test-secret-access-key",
             };
 
-        devProcess = spawn("npx", ["-y", "@514labs/moose-cli@0.6.201", "dev"], {
+        devProcess = spawn("npx", ["-y", "@514labs/moose-cli@latest", "dev"], {
           stdio: "pipe",
           cwd: TEST_PROJECT_DIR,
           env: devEnv,
@@ -317,7 +317,7 @@ describe("Backward Compatibility Tests", function () {
           SERVER_CONFIG.startupMessage,
           SERVER_CONFIG.url,
         );
-        console.log("Server started with 0.6.201 CLI, infrastructure is ready");
+        console.log("Server started with latest CLI, infrastructure is ready");
         // Brief wait to ensure everything is fully settled
         await setTimeoutAsync(5000);
 

packages/py-moose-lib/moose_lib/main.py

@@ -185,7 +185,7 @@ def __init__(self, ch_client_or_config: Union[ClickhouseClient, RuntimeClickHous
     def __call__(self, input, variables):
         return self.execute(input, variables)
 
-    def execute(self, input: Union[str, Query], variables = None, row_type: Type[BaseModel] = None):
+    def execute(self, input: Union[str, Query], variables=None, row_type: Type[BaseModel] = None):
         """
         Execute a query.
 
@@ -212,21 +212,30 @@ def execute(self, input: Union[str, Query], variables = None, row_type: Type[Bas
         values: dict[str, Any] = {}
         preview_params = {}
 
-        for i, (_, variable_name, _, _) in enumerate(Formatter().parse(input)):
+        i = 0
+        for _, variable_name, _, _ in Formatter().parse(input):
             if variable_name:
                 value = variables[variable_name]
                 if isinstance(value, list) and len(value) == 1:
                     # handling passing the value of the query string dict directly to variables
                     value = value[0]
 
                 if isinstance(value, Column) or isinstance(value, OlapTable):
-                    params[variable_name] = f'{{p{i}: Identifier}}'
-                    values[f'p{i}'] = value.name
+                    if isinstance(value, OlapTable) and value.config.database:
+                        params[variable_name] = f'{{p{i}: Identifier}}.{{p{i + 1}: Identifier}}'
+                        values[f'p{i}'] = value.config.database
+                        values[f'p{i + 1}'] = value.name
+                        i += 2
+                    else:
+                        params[variable_name] = f'{{p{i}: Identifier}}'
+                        values[f'p{i}'] = value.name
+                        i += 1
                 else:
                     from moose_lib.utilities.sql import clickhouse_param_type_for_value
                     ch_type = clickhouse_param_type_for_value(value)
                     params[variable_name] = f'{{p{i}: {ch_type}}}'
                     values[f'p{i}'] = value
+                    i += 1
                 preview_params[variable_name] = self._format_value_for_preview(value)
 
         clickhouse_query = input.format_map(params)
@@ -290,6 +299,9 @@ def _format_value_for_preview(self, value: Any) -> str:
         if isinstance(value, datetime):
             return f"'{value.strftime('%Y-%m-%d %H:%M:%S')}'"
 
+        if isinstance(value, OlapTable) and value.config.database:
+            return f"{value.config.database}.{value.name}"
+
         if isinstance(value, Column) or isinstance(value, OlapTable):
             return value.name
 

packages/py-moose-lib/tests/test_query_builder.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 
 from moose_lib.query_builder import Query, col
-from moose_lib.dmv2 import IngestPipeline, IngestPipelineConfig
+from moose_lib.dmv2 import IngestPipeline, IngestPipelineConfig, OlapTable, OlapConfig
 from pydantic import BaseModel
 from moose_lib.data_models import Key
 
@@ -36,3 +36,76 @@ def test_simple_select_and_where():
     assert params == {"p0": True}
 
 
+def test_table_with_database_config():
+    """Test that tables with database config generate correct SQL with two identifiers"""
+
+    class TestModel(BaseModel):
+        id: int
+        name: str
+
+    # Table without database
+    table_without_db = OlapTable[TestModel]("my_table_no_db", OlapConfig())
+
+    # Table with database
+    table_with_db = OlapTable[TestModel]("my_table_with_db", OlapConfig(database="my_database"))
+
+    # Test Query builder with table that has database
+    q1 = Query().from_(table_with_db).select(table_with_db.cols.id, table_with_db.cols.name)
+    sql1 = q1.to_sql()
+    # The Query builder should handle the database-qualified table reference
+    assert "my_database" in sql1 or "my_table" in sql1
+
+    # Test string interpolation format for QueryClient.execute()
+    # When a table with database is used, it should generate two separate Identifier parameters
+    from string import Formatter
+
+    # Simulate what happens in QueryClient.execute() with a table that has database
+    template = "SELECT * FROM {table}"
+    variables = {"table": table_with_db}
+
+    params = {}
+    values = {}
+    i = 0
+
+    for _, variable_name, _, _ in Formatter().parse(template):
+        if variable_name:
+            value = variables[variable_name]
+            if isinstance(value, OlapTable) and value.config.database:
+                # Should use two separate Identifier parameters
+                params[variable_name] = f'{{p{i}: Identifier}}.{{p{i + 1}: Identifier}}'
+                values[f'p{i}'] = value.config.database
+                values[f'p{i + 1}'] = value.name
+                i += 2
+            else:
+                params[variable_name] = f'{{p{i}: Identifier}}'
+                values[f'p{i}'] = value.name
+                i += 1
+
+    clickhouse_query = template.format_map(params)
+
+    assert clickhouse_query == "SELECT * FROM {p0: Identifier}.{p1: Identifier}"
+    assert values == {"p0": "my_database", "p1": "my_table_with_db"}
+
+    # Test with table without database
+    variables_no_db = {"table": table_without_db}
+    params_no_db = {}
+    values_no_db = {}
+    i = 0
+
+    for _, variable_name, _, _ in Formatter().parse(template):
+        if variable_name:
+            value = variables_no_db[variable_name]
+            if isinstance(value, OlapTable) and value.config.database:
+                params_no_db[variable_name] = f'{{p{i}: Identifier}}.{{p{i + 1}: Identifier}}'
+                values_no_db[f'p{i}'] = value.config.database
+                values_no_db[f'p{i + 1}'] = value.name
+                i += 2
+            else:
+                params_no_db[variable_name] = f'{{p{i}: Identifier}}'
+                values_no_db[f'p{i}'] = value.name
+                i += 1
+
+    clickhouse_query_no_db = template.format_map(params_no_db)
+
+    assert clickhouse_query_no_db == "SELECT * FROM {p0: Identifier}"
+    assert values_no_db == {"p0": "my_table_no_db"}

packages/ts-moose-lib/src/sqlHelpers.ts

@@ -127,7 +127,11 @@ export class Sql {
         }
         this.strings[pos] += rawString;
       } else if (isTable(child)) {
-        this.strings[pos] += `\`${child.name}\``;
+        if (child.config.database) {
+          this.strings[pos] += `\`${child.config.database}\`.\`${child.name}\``;
+        } else {
+          this.strings[pos] += `\`${child.name}\``;
+        }
         this.strings[pos] += rawString;
       } else {
         this.values[pos++] = child;

packages/ts-moose-lib/tests/standalone.test.ts

@@ -1,6 +1,7 @@
 import { expect } from "chai";
 import { getMooseClients } from "../src/consumption-apis/standalone";
 import { sql } from "../src/sqlHelpers";
+import { OlapTable } from "../src/dmv2";
 
 describe("BYOF Standalone Functionality", function () {
   this.timeout(10000);
@@ -128,6 +129,77 @@ describe("BYOF Standalone Functionality", function () {
     });
   });
 
+  describe("sql template tag with database-qualified tables", () => {
+    it("should handle table without database config", () => {
+      interface TestModel1 {
+        id: number;
+        name: string;
+      }
+
+      const table = new OlapTable<TestModel1>("table_no_db");
+      const query = sql`SELECT * FROM ${table}`;
+
+      // Table without database should be rendered inline as `table_no_db`
+      // The sql template tag concatenates the table directly into strings
+      expect(query.strings.join("")).to.include("`table_no_db`");
+      expect(query.values).to.have.lengthOf(0);
+    });
+
+    it("should handle table with database config", () => {
+      interface TestModel2 {
+        id: number;
+        name: string;
+      }
+
+      const table = new OlapTable<TestModel2>("table_with_db", {
+        database: "my_database",
+      });
+      const query = sql`SELECT * FROM ${table}`;
+
+      // Table with database should be rendered as `my_database`.`table_with_db`
+      const fullQuery = query.strings.join("");
+      expect(fullQuery).to.include("`my_database`.`table_with_db`");
+      expect(query.values).to.have.lengthOf(0);
+    });
+
+    it("should handle multiple tables with different database configs", () => {
+      interface TestModel3 {
+        id: number;
+        name: string;
+      }
+
+      const table1 = new OlapTable<TestModel3>("multi_table1", {
+        database: "db1",
+      });
+      const table2 = new OlapTable<TestModel3>("multi_table2"); // no database
+      const query = sql`SELECT * FROM ${table1} JOIN ${table2}`;
+
+      // Should properly interpolate both tables
+      const fullQuery = query.strings.join("");
+      expect(fullQuery).to.include("`db1`.`multi_table1`");
+      expect(fullQuery).to.include("`multi_table2`");
+      expect(query.values).to.have.lengthOf(0);
+    });
+
+    it("should handle table in WHERE clause with database config", () => {
+      interface TestModel4 {
+        id: number;
+        name: string;
+      }
+
+      const table = new OlapTable<TestModel4>("events_table", {
+        database: "analytics",
+      });
+      const userId = 123;
+      const query = sql`SELECT * FROM ${table} WHERE user_id = ${userId}`;
+
+      const fullQuery = query.strings.join("");
+      expect(fullQuery).to.include("`analytics`.`events_table`");
+      expect(query.values).to.have.lengthOf(1);
+      expect(query.values[0]).to.equal(123);
+    });
+  });
+
   describe("Integration: getMooseClients + sql", () => {
     it("should work together to create queries", async () => {
       const { client } = await getMooseClients();