feat(duckdb-driver): Fix numeric filter comparisons in DuckDB

Fixes [#9281](#9281) by implementing explicit CAST for numeric filters in the DuckDB driver. This ensures correct numeric comparisons and prevents mismatches caused by string-to-number conversions.

Added test cases to validate casting behavior for different filter scenarios.

Author: karlomedallo

packages/cubejs-duckdb-driver/src/DuckDBQuery.ts

@@ -12,6 +12,12 @@ const GRANULARITY_TO_INTERVAL: Record<string, (date: string) => string> = {
 };
 
 class DuckDBFilter extends BaseFilter {
+  public castParameter() {
+    if (this.measure || this.definition().type === 'number') {
+      return 'CAST(? AS DOUBLE)';
+    }
+    return '?';
+  }
 }
 
 export class DuckDBQuery extends BaseQuery {

packages/cubejs-testing/birdbox-fixtures/duckdb/schema/Orders.js

@@ -29,5 +29,9 @@ cube(`Orders`, {
       sql: `status`,
       type: `string`,
     },
+    amount: {
+      sql: `amount`,
+      type: `number`,
+    },
   },
 });

packages/cubejs-testing/test/smoke-duckdb.test.ts

@@ -1,6 +1,6 @@
 import cubejs, { CubeApi } from '@cubejs-client/core';
 // eslint-disable-next-line import/no-extraneous-dependencies
-import { afterAll, beforeAll, jest } from '@jest/globals';
+import { afterAll, beforeAll, expect, jest, test } from '@jest/globals';
 import { BirdBox, getBirdbox } from '../src';
 import {
   DEFAULT_API_TOKEN,
@@ -37,4 +37,119 @@ describe('duckdb', () => {
   }, JEST_AFTER_ALL_DEFAULT_TIMEOUT);
 
   test('query measure', () => testQueryMeasure(client));
+
+  test('numeric measure filter - uses CAST', async () => {
+    const response = await client.load({
+      measures: [
+        'Orders.count'
+      ],
+      filters: [
+        {
+          member: 'Orders.totalAmount',
+          operator: 'gte',
+          values: ['300']
+        }
+      ]
+    });
+    
+    // The HAVING clause applies after counting all records
+    expect(response.rawData()[0]['Orders.count']).toBe('5');
+  });
+  
+  test('numeric dimension filter - uses CAST', async () => {
+    // This test verifies that the WHERE clause for numeric dimensions uses CAST(? AS DOUBLE)
+    const response = await client.load({
+      measures: [
+        'Orders.count'
+      ],
+      filters: [
+        {
+          member: 'Orders.amount',
+          operator: 'gte',
+          values: ['300']
+        }
+      ]
+    });
+    
+    // Only 3 orders have amount >= 300
+    expect(response.rawData()[0]['Orders.count']).toBe('3');
+  });
+  
+  test('string filter - does NOT use CAST', async () => {
+    // This test verifies that the WHERE clause for string dimensions does not use CAST
+    const response = await client.load({
+      measures: [
+        'Orders.count'
+      ],
+      filters: [
+        {
+          member: 'Orders.status',
+          operator: 'equals',
+          values: ['processed']
+        }
+      ]
+    });
+    
+    // There are 2 'processed' orders 
+    expect(response.rawData()[0]['Orders.count']).toBe('2');
+  });
+  
+  test('numeric exact equality filter - also uses CAST', async () => {
+    // This test verifies that even for equality comparisons on numeric values, CAST is used
+    const response = await client.load({
+      measures: [
+        'Orders.count'
+      ],
+      filters: [
+        {
+          member: 'Orders.amount',
+          operator: 'equals',
+          values: ['300']
+        }
+      ]
+    });
+    
+    // Only 1 order has amount exactly 300
+    expect(response.rawData()[0]['Orders.count']).toBe('1');
+  });
+  
+  test('numeric string comparison - values are properly handled with CAST', async () => {
+    // This test verifies that numeric strings are properly cast as numbers
+    // This is important because '100' and 100 are different in string comparisons
+    // but should be treated the same with numeric CAST
+    const response = await client.load({
+      measures: [
+        'Orders.count'
+      ],
+      filters: [
+        {
+          member: 'Orders.amount',
+          operator: 'equals',
+          values: ['100'] // string '100' should be cast to number 100
+        }
+      ]
+    });
+    
+    // Only 1 order has amount 100
+    expect(response.rawData()[0]['Orders.count']).toBe('1');
+  });
+  
+  test('multiple string values in filter - none use CAST', async () => {
+    // This test verifies that IN (...) clauses for string dimensions don't use CAST
+    const response = await client.load({
+      measures: [
+        'Orders.count'
+      ],
+      filters: [
+        {
+          member: 'Orders.status',
+          operator: 'equals',
+          values: ['new', 'processed']
+        }
+      ]
+    });
+    
+    // There are 4 orders with status 'new' or 'processed'
+    expect(response.rawData()[0]['Orders.count']).toBe('4');
+  });
 });