added mapping of integers, array of strings for SQLCommonParam

Author: OleksiiKH0240

integration-tests/tests/clickhouse/clickhouse-core.ts

@@ -184,13 +184,13 @@ export const commonClickHouseTests = () => {
 		test('base test with number param', (ctx) => {
 			const res = ctx.sql`select ${1};`.toSQL();
 
-			expect(res).toStrictEqual({ query: `select {param1:String};`, params: { param1: 1 } });
+			expect(res).toStrictEqual({ query: `select {param1:Int32};`, params: { param1: 1 } });
 		});
 
 		test('base test with bigint param', (ctx) => {
 			const res = ctx.sql`select ${BigInt(10)};`.toSQL();
 
-			expect(res).toStrictEqual({ query: `select {param1:String};`, params: { param1: 10n } });
+			expect(res).toStrictEqual({ query: `select {param1:Int64};`, params: { param1: 10n } });
 		});
 
 		test('base test with string param', (ctx) => {
@@ -226,7 +226,7 @@ export const commonClickHouseTests = () => {
 
 			const res = query.toSQL();
 			expect(res).toStrictEqual({
-				query: 'select * from users where id = {param1:String} or id = {param2:String} or id = {param3:String};',
+				query: 'select * from users where id = {param1:Int32} or id = {param2:Int32} or id = {param3:Int32};',
 				params: { param1: 1, param2: 3, param3: 4 },
 			});
 		});

integration-tests/tests/clickhouse/waddler.test.ts

@@ -1144,11 +1144,11 @@ test('sql query api test', async () => {
 	const query = sql`select * from ${sqlQuery.identifier('users')} where ${filter};`;
 
 	expect(query.toSQL()).toStrictEqual({
-		query: 'select * from `users` where id = {param1:Int32} or id = {param2:String} and email = {param3:String}',
+		query: 'select * from `users` where id = {param1:Int32} or id = {param2:Int32} and email = {param3:String}',
 		params: { param1: 1, param2: 2, param3: 'hello@test.com' },
 	});
 	expect(filter.toSQL()).toStrictEqual({
-		sql: 'id = {param1:Int32} or id = {param2:String} and email = {param3:String}',
+		sql: 'id = {param1:Int32} or id = {param2:Int32} and email = {param3:String}',
 		params: { param1: 1, param2: 2, param3: 'hello@test.com' },
 	});
 });
@@ -1201,14 +1201,90 @@ engine = MergeTree
 order by id;
   `).command();
 
-	const valuesIds = Array.from({ length: 10 ** 3 }).fill([1]) as number[][];
+	const valuesIds = Array.from({ length: 10 ** 1 }).fill([1]) as number[][];
 
 	console.time('insert');
-	await sql`insert into ${sql.identifier('tests')} values ${sql.values(valuesIds)};`.command();
+	const query = sql`insert into ${sql.identifier('tests')} values ${sql.values(valuesIds)};`.command();
+	const { query: rawSql, params } = query.toSQL();
+	// await query;
+	// const rawSqlNew = rawSql.slice(0, -1) + ' FORMAT JSONEachRow;';
+	await clickHouseClient.command({ query: rawSql, query_params: params as Record<string, any> });
+	await clickHouseClient.insert({
+		table: 'tests',
+		query_params: params as Record<string, any>,
+		values: valuesIds,
+	});
+
 	console.timeEnd('insert');
 	// console.log('New user created!');
 	// const ids = await sql`select * from ${sql.identifier('tests')};`.query();
 	// console.log('Getting all users from the database:', ids);
 
 	await sql.unsafe(`drop table tests;`).command();
 });
+
+test('1d array of strings, integer as SQLCommonParam test', async () => {
+	await sql.unsafe(`create table tests(
+    id    Int32,
+	path  String
+)
+engine = MergeTree
+order by id;
+  `).command();
+
+	const valuesToInsert = [[1, '/'], [2, '/watch'], [3, '/over_watch']];
+
+	await sql`insert into tests values ${sql.values(valuesToInsert)};`.command();
+
+	// case0
+	const query0 = sql`select * from tests where path in ${['/', '/watch']};`;
+	expect(query0.toSQL()).toStrictEqual({
+		query: 'select * from tests where path in {param1:Array(String)};',
+		params: { param1: ['/', '/watch'] },
+	});
+
+	const res0 = await query0;
+	expect(res0).toStrictEqual([{ id: 1, path: '/' }, { id: 2, path: '/watch' }]);
+
+	// case1 (datetime)
+	const query1 = sql`select toDateTime(${1754055760745}, 3) as some_datetime;`;
+	expect(query1.toSQL()).toStrictEqual({
+		query: 'select toDateTime({param1:Int64}, 3) as some_datetime;',
+		params: { param1: 1754055760745 },
+	});
+
+	const res1 = await query1;
+	expect(res1.length).equal(1);
+
+	// case2 (int32 max)
+	const query2 = sql`select ${2_147_483_647} as max_int32;`;
+	expect(query2.toSQL()).toStrictEqual({
+		query: 'select {param1:Int32} as max_int32;',
+		params: { param1: 2147483647 },
+	});
+
+	const res2 = await query2;
+	expect(res2).toStrictEqual([{ max_int32: 2147483647 }]);
+
+	// case3 (int32 min)
+	const query3 = sql`select ${-2_147_483_648} as min_int32;`;
+	expect(query3.toSQL()).toStrictEqual({
+		query: 'select {param1:Int32} as min_int32;',
+		params: { param1: -2147483648 },
+	});
+
+	const res3 = await query3;
+	expect(res3).toStrictEqual([{ min_int32: -2147483648 }]);
+
+	// case4 (float)
+	const query4 = sql`select ${-2_147_483_648.123} as some_float;`;
+	expect(query4.toSQL()).toStrictEqual({
+		query: 'select {param1:String} as some_float;',
+		params: { param1: -2147483648.123 },
+	});
+
+	const res4 = await query4;
+	expect(res4).toStrictEqual([{ some_float: '-2147483648.123' }]);
+
+	await sql.unsafe(`drop table tests;`).command();
+});

waddler/src/clickhouse-core/utils.ts

@@ -66,3 +66,33 @@ export const getArrayDepth = (value: any[]) => {
 		return Math.max(d, maxDepth);
 	}, 0);
 };
+
+export const inspectArray = (value: any[]): { depth: number; type: string } => {
+	if (Array.isArray(value)) {
+		const { depth, type } = inspectArray(value[0]);
+		return { depth: depth + 1, type };
+	}
+
+	return { depth: 0, type: typeof value };
+};
+
+export const inspectArray1 = (value: any[]): { depth: number; type: string } => {
+	let currNode: any | any[] = value;
+	let depth: number = 0;
+
+	for (let i = 0; i < 100; i++) {
+		if (!Array.isArray(currNode)) return { depth, type: typeof currNode };
+		currNode = currNode[0];
+		depth++;
+	}
+
+	return { depth, type: typeof value };
+};
+
+// console.log(inspectArray(['a', 'b']));
+// console.log(inspectArray([['a', 'b'], ['a', 'b']]));
+// console.log(inspectArray([[['a', 'b'], ['a', 'b']], [['a', 'b'], ['a', 'b']]]));
+
+// console.log(inspectArray1(['a', 'b']));
+// console.log(inspectArray1([['a', 'b'], ['a', 'b']]));
+// console.log(inspectArray1([[['a', 'b'], ['a', 'b']], [['a', 'b'], ['a', 'b']]]));

waddler/src/clickhouse/session.ts

@@ -46,7 +46,7 @@ export class ClickHouseSQLTemplate<T> extends SQLTemplate<T> {
 				}) as any;
 			}
 		} catch (error) {
-			throw new WaddlerQueryError(query, params, error as Error);
+			throw new WaddlerQueryError(query, JSON.stringify(params), error as Error);
 		}
 	}
 

waddler/src/errors/index.ts

@@ -1,7 +1,7 @@
 export class WaddlerQueryError extends Error {
 	constructor(
 		public query: string,
-		public params: any[] | Record<string, any>,
+		public params: any[] | Record<string, any> | any,
 		public override cause?: Error,
 	) {
 		super(`Failed query: ${query}\nparams: ${params}`);

waddler/src/sql-template-params.ts

@@ -61,16 +61,36 @@ export class SQLQuery extends SQLChunk {
 }
 
 export class SQLCommonParam extends SQLChunk {
+	INT32_MAX = 2_147_483_647;
+	INT32_MIN = -2_147_483_648;
+
 	constructor(
 		readonly value: UnsafeParamType,
-		readonly type: string = 'String',
+		public type: string = 'String',
 	) {
 		super();
 	}
 
 	generateSQL(
 		{ dialect, lastParamIdx }: { dialect: Dialect; lastParamIdx: number },
 	) {
+		// bigint case
+		if (typeof this.value === 'bigint') this.type = 'Int64';
+
+		// integer case
+		if (typeof this.value === 'number' && this.value % 1 === 0) {
+			this.type = 'Int32';
+			if (this.value > this.INT32_MAX || this.value < this.INT32_MIN) {
+				this.type = 'Int64';
+			}
+		}
+
+		// array case
+		if (Array.isArray(this.value)) {
+			const nodeType = typeof this.value[0];
+			if (nodeType === 'string') this.type = 'Array(String)';
+		}
+
 		const params = dialect.createEmptyParams();
 		dialect.pushParams(params, this.value, lastParamIdx + 1, 'single');
 		return {