chore: import upstream snapshot with attribution

drizzle-orm/tests/casing/casing.test.ts

@@ -0,0 +1,28 @@
+import { describe, it } from 'vitest';
+import { toCamelCase, toSnakeCase } from '~/casing';
+
+describe.concurrent('casing', () => {
+	it('transforms to snake case', ({ expect }) => {
+		expect(toSnakeCase('drizzleKit')).toEqual('drizzle_kit');
+	});
+
+	it('transforms an uppercase acronym/abbreviation to snake case', ({ expect }) => {
+		expect(toSnakeCase('drizzleORM')).toEqual('drizzle_orm');
+	});
+
+	it('transforms a camel case acronym/abbreviation to snake case', ({ expect }) => {
+		expect(toSnakeCase('drizzleOrm')).toEqual('drizzle_orm');
+	});
+
+	it('transforms an uppercase acronym/abbreviation followed by a word to snake case', ({ expect }) => {
+		expect(toSnakeCase('drizzleORMAndKit')).toEqual('drizzle_orm_and_kit');
+	});
+
+	it('transforms a camel case acronym/abbreviation followed by a word to snake case', ({ expect }) => {
+		expect(toSnakeCase('drizzleOrmAndKit')).toEqual('drizzle_orm_and_kit');
+	});
+
+	it('transforms to camel case 1', ({ expect }) => {
+		expect(toCamelCase('drizzle_kit')).toEqual('drizzleKit');
+	});
+});

drizzle-orm/tests/casing/mysql-to-camel.test.ts

@@ -0,0 +1,299 @@
+import { Client } from '@planetscale/database';
+import { connect } from '@tidbcloud/serverless';
+import { beforeEach, describe, it } from 'vitest';
+import { alias, boolean, int, mysqlSchema, mysqlTable, serial, text, union } from '~/mysql-core';
+import { drizzle as planetscale } from '~/planetscale-serverless';
+import { relations } from '~/relations';
+import { asc, eq, sql } from '~/sql';
+import { drizzle as mysql } from '~/tidb-serverless';
+
+const testSchema = mysqlSchema('test');
+const users = mysqlTable('users', {
+	id: serial().primaryKey(),
+	first_name: text().notNull(),
+	last_name: text().notNull(),
+	// Test that custom aliases remain
+	age: int('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	user_id: serial().primaryKey().references(() => users.id),
+	uses_drizzle_orm: boolean().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.user_id],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = mysql(connect({}), { schema, casing: 'camelCase' });
+const ps = planetscale(new Client({}), { schema, casing: 'camelCase' });
+
+const usersCache = {
+	'public.users.id': 'id',
+	'public.users.first_name': 'firstName',
+	'public.users.last_name': 'lastName',
+	'public.users.AGE': 'age',
+};
+const developersCache = {
+	'test.developers.user_id': 'userId',
+	'test.developers.uses_drizzle_orm': 'usesDrizzleOrm',
+};
+const cache = {
+	...usersCache,
+	...developersCache,
+};
+
+const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
+
+describe('mysql to snake case', () => {
+	beforeEach(() => {
+		ps.dialect.casing.clearCache();
+		db.dialect.casing.clearCache();
+	});
+
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users`.`AGE` from `users` left join `test`.`developers` on `users`.`id` = `test`.`developers`.`userId` order by `users`.`firstName` asc",
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.first_name })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.user_id));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select `users`.`firstName` from `users` left join `test`.`developers` `devs` on `users`.`id` = `devs`.`userId`',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with `cte` as (select `firstName` || ' ' || `lastName` as `name` from `users`) select `name` from `cte`",
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with `cte` as (select `firstName` || ' ' || `lastName` as `name` from `users`) select `name` from `cte`",
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.first_name })
+			.from(users)
+			.union(db.select({ firstName: users.first_name }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select `firstName` from `users`) union (select `firstName` from `users`)',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.first_name }).from(users),
+			db.select({ firstName: users.first_name }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select `firstName` from `users`) union (select `firstName` from `users`)',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`id`, `users`.`AGE`, `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`usesDrizzleOrm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ? limit ?",
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find first, planetscale)', ({ expect }) => {
+		const query = ps.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `id`, `AGE`, `firstName` || ' ' || `lastName` as `name`, (select json_array(`usesDrizzleOrm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ? limit ?",
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(ps.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`id`, `users`.`AGE`, `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`usesDrizzleOrm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ?",
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many, planetscale)', ({ expect }) => {
+		const query = ps.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `id`, `AGE`, `firstName` || ' ' || `lastName` as `name`, (select json_array(`usesDrizzleOrm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ?",
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(ps.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('insert', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'insert into `users` (`id`, `firstName`, `lastName`, `AGE`) values (default, ?, ?, ?)',
+			params: ['John', 'Doe', 30],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('insert (on duplicate key update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onDuplicateKeyUpdate({ set: { age: 31 } });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into `users` (`id`, `firstName`, `lastName`, `AGE`) values (default, ?, ?, ?) on duplicate key update `AGE` = ?',
+			params: ['John', 'Doe', 30, 31],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'update `users` set `firstName` = ?, `lastName` = ?, `AGE` = ? where `users`.`id` = ?',
+			params: ['John', 'Doe', 30, 1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from `users` where `users`.`id` = ?',
+			params: [1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+});

drizzle-orm/tests/casing/mysql-to-snake.test.ts

@@ -0,0 +1,299 @@
+import { Client } from '@planetscale/database';
+import { connect } from '@tidbcloud/serverless';
+import { beforeEach, describe, it } from 'vitest';
+import { alias, boolean, int, mysqlSchema, mysqlTable, serial, text, union } from '~/mysql-core';
+import { drizzle as planetscale } from '~/planetscale-serverless';
+import { relations } from '~/relations';
+import { asc, eq, sql } from '~/sql';
+import { drizzle as mysql } from '~/tidb-serverless';
+
+const testSchema = mysqlSchema('test');
+const users = mysqlTable('users', {
+	id: serial().primaryKey(),
+	firstName: text().notNull(),
+	lastName: text().notNull(),
+	// Test that custom aliases remain
+	age: int('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	userId: serial().primaryKey().references(() => users.id),
+	usesDrizzleORM: boolean().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.userId],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = mysql(connect({}), { schema, casing: 'snake_case' });
+const ps = planetscale(new Client({}), { schema, casing: 'snake_case' });
+
+const usersCache = {
+	'public.users.id': 'id',
+	'public.users.firstName': 'first_name',
+	'public.users.lastName': 'last_name',
+	'public.users.AGE': 'age',
+};
+const developersCache = {
+	'test.developers.userId': 'user_id',
+	'test.developers.usesDrizzleORM': 'uses_drizzle_orm',
+};
+const cache = {
+	...usersCache,
+	...developersCache,
+};
+
+const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
+
+describe('mysql to snake case', () => {
+	beforeEach(() => {
+		db.dialect.casing.clearCache();
+		ps.dialect.casing.clearCache();
+	});
+
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users`.`AGE` from `users` left join `test`.`developers` on `users`.`id` = `test`.`developers`.`user_id` order by `users`.`first_name` asc",
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.userId));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select `users`.`first_name` from `users` left join `test`.`developers` `devs` on `users`.`id` = `devs`.`user_id`',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with `cte` as (select `first_name` || ' ' || `last_name` as `name` from `users`) select `name` from `cte`",
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with `cte` as (select `first_name` || ' ' || `last_name` as `name` from `users`) select `name` from `cte`",
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.union(db.select({ firstName: users.firstName }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select `first_name` from `users`) union (select `first_name` from `users`)',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.firstName }).from(users),
+			db.select({ firstName: users.firstName }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select `first_name` from `users`) union (select `first_name` from `users`)',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`id`, `users`.`AGE`, `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`uses_drizzle_orm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ? limit ?",
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find first, planetscale)', ({ expect }) => {
+		const query = ps.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `id`, `AGE`, `first_name` || ' ' || `last_name` as `name`, (select json_array(`uses_drizzle_orm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ? limit ?",
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(ps.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`id`, `users`.`AGE`, `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`uses_drizzle_orm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ?",
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many, planetscale)', ({ expect }) => {
+		const query = ps.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `id`, `AGE`, `first_name` || ' ' || `last_name` as `name`, (select json_array(`uses_drizzle_orm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ?",
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(ps.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('insert', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'insert into `users` (`id`, `first_name`, `last_name`, `AGE`) values (default, ?, ?, ?)',
+			params: ['John', 'Doe', 30],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('insert (on duplicate key update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onDuplicateKeyUpdate({ set: { age: 31 } });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into `users` (`id`, `first_name`, `last_name`, `AGE`) values (default, ?, ?, ?) on duplicate key update `AGE` = ?',
+			params: ['John', 'Doe', 30, 31],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'update `users` set `first_name` = ?, `last_name` = ?, `AGE` = ? where `users`.`id` = ?',
+			params: ['John', 'Doe', 30, 1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from `users` where `users`.`id` = ?',
+			params: [1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+});

drizzle-orm/tests/casing/pg-to-camel.test.ts

@@ -0,0 +1,246 @@
+import postgres from 'postgres';
+import { beforeEach, describe, it } from 'vitest';
+import { alias, boolean, integer, pgSchema, pgTable, serial, text, union } from '~/pg-core';
+import { drizzle } from '~/postgres-js';
+import { relations } from '~/relations';
+import { asc, eq, sql } from '~/sql';
+
+const testSchema = pgSchema('test');
+const users = pgTable('users', {
+	id: serial().primaryKey(),
+	first_name: text().notNull(),
+	last_name: text().notNull(),
+	// Test that custom aliases remain
+	age: integer('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	user_id: serial().primaryKey().references(() => users.id),
+	uses_drizzle_orm: boolean().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.user_id],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle(postgres(''), { schema, casing: 'camelCase' });
+
+const usersCache = {
+	'public.users.id': 'id',
+	'public.users.first_name': 'firstName',
+	'public.users.last_name': 'lastName',
+	'public.users.AGE': 'age',
+};
+const developersCache = {
+	'test.developers.user_id': 'userId',
+	'test.developers.uses_drizzle_orm': 'usesDrizzleOrm',
+};
+const cache = {
+	...usersCache,
+	...developersCache,
+};
+
+const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
+
+describe('postgres to camel case', () => {
+	beforeEach(() => {
+		db.dialect.casing.clearCache();
+	});
+
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" from "users" left join "test"."developers" on "users"."id" = "test"."developers"."userId" order by "users"."firstName" asc',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ first_name: users.first_name })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.user_id));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" from "users" left join "test"."developers" "devs" on "users"."id" = "devs"."userId"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ first_name: users.first_name })
+			.from(users)
+			.union(db.select({ first_name: users.first_name }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "firstName" from "users") union (select "firstName" from "users")',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ first_name: users.first_name }).from(users),
+			db.select({ first_name: users.first_name }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "firstName" from "users") union (select "firstName" from "users")',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."firstName" || \' \' || "users"."lastName" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."usesDrizzleOrm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."userId" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2 limit $3',
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."firstName" || \' \' || "users"."lastName" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."usesDrizzleOrm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."userId" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2',
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('insert (on conflict do nothing)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoNothing({ target: users.first_name })
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("firstName") do nothing returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('insert (on conflict do update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.first_name, set: { age: 31 } })
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("firstName") do update set "AGE" = $4 returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30, 31],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "firstName" = $1, "lastName" = $2, "AGE" = $3 where "users"."id" = $4 returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "firstName", "AGE"',
+			params: [1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+});

drizzle-orm/tests/casing/pg-to-snake.test.ts

@@ -0,0 +1,248 @@
+import postgres from 'postgres';
+import { beforeEach, describe, it } from 'vitest';
+import { alias, boolean, integer, pgSchema, pgTable, serial, text, union } from '~/pg-core';
+import { drizzle } from '~/postgres-js';
+import { relations } from '~/relations';
+import { asc, eq, sql } from '~/sql';
+
+const testSchema = pgSchema('test');
+const users = pgTable('users', {
+	id: serial().primaryKey(),
+	firstName: text().notNull(),
+	lastName: text().notNull(),
+	// Test that custom aliases remain
+	age: integer('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	userId: serial().primaryKey().references(() => users.id),
+	usesDrizzleORM: boolean().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.userId],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle(postgres(''), { schema, casing: 'snake_case' });
+
+const usersCache = {
+	'public.users.id': 'id',
+	'public.users.firstName': 'first_name',
+	'public.users.lastName': 'last_name',
+	'public.users.AGE': 'age',
+};
+const developersCache = {
+	'test.developers.userId': 'user_id',
+	'test.developers.usesDrizzleORM': 'uses_drizzle_orm',
+};
+const cache = {
+	...usersCache,
+	...developersCache,
+};
+
+const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
+
+describe('postgres to snake case', () => {
+	beforeEach(() => {
+		db.dialect.casing.clearCache();
+	});
+
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" from "users" left join "test"."developers" on "users"."id" = "test"."developers"."user_id" order by "users"."first_name" asc',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.userId));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" from "users" left join "test"."developers" "devs" on "users"."id" = "devs"."user_id"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.union(db.select({ firstName: users.firstName }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "first_name" from "users") union (select "first_name" from "users")',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.firstName }).from(users),
+			db.select({ firstName: users.firstName }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "first_name" from "users") union (select "first_name" from "users")',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."first_name" || \' \' || "users"."last_name" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."uses_drizzle_orm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2 limit $3',
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."first_name" || \' \' || "users"."last_name" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."uses_drizzle_orm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2',
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('insert (on conflict do nothing)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoNothing({ target: users.firstName })
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("first_name") do nothing returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('insert (on conflict do update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.firstName, set: { age: 31 } })
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("first_name") do update set "AGE" = $4 returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30, 31],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "first_name" = $1, "last_name" = $2, "AGE" = $3 where "users"."id" = $4 returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "first_name", "AGE"',
+			params: [1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+});

drizzle-orm/tests/casing/sqlite-to-camel.test.ts

@@ -0,0 +1,244 @@
+import Database from 'better-sqlite3';
+import { beforeEach, describe, it } from 'vitest';
+import { drizzle } from '~/better-sqlite3';
+import { relations } from '~/relations';
+import { asc, eq, sql } from '~/sql';
+import { alias, integer, sqliteTable, text, union } from '~/sqlite-core';
+
+const users = sqliteTable('users', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	first_name: text().notNull(),
+	last_name: text().notNull(),
+	// Test that custom aliases remain
+	age: integer('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = sqliteTable('developers', {
+	user_id: integer().primaryKey().references(() => users.id),
+	uses_drizzle_orm: integer({ mode: 'boolean' }).notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.user_id],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle(new Database(':memory:'), { schema, casing: 'camelCase' });
+
+const usersCache = {
+	'public.users.id': 'id',
+	'public.users.first_name': 'firstName',
+	'public.users.last_name': 'lastName',
+	'public.users.AGE': 'age',
+};
+const developersCache = {
+	'public.developers.user_id': 'userId',
+	'public.developers.uses_drizzle_orm': 'usesDrizzleOrm',
+};
+const cache = {
+	...usersCache,
+	...developersCache,
+};
+
+const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
+
+describe('sqlite to camel case', () => {
+	beforeEach(() => {
+		db.dialect.casing.clearCache();
+	});
+
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" from "users" left join "developers" on "users"."id" = "developers"."userId" order by "users"."firstName" asc',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ first_name: users.first_name })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.user_id));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "users"."firstName" from "users" left join "developers" "devs" on "users"."id" = "devs"."userId"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ first_name: users.first_name })
+			.from(users)
+			.union(db.select({ first_name: users.first_name }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "firstName" from "users" union select "firstName" from "users"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ first_name: users.first_name }).from(users),
+			db.select({ first_name: users.first_name }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "firstName" from "users" union select "firstName" from "users"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "id", "AGE", "firstName" || \' \' || "lastName" as "name", (select json_array("usesDrizzleOrm") as "data" from (select * from "developers" "users_developers" where "users_developers"."userId" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ? limit ?',
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "id", "AGE", "firstName" || \' \' || "lastName" as "name", (select json_array("usesDrizzleOrm") as "data" from (select * from "developers" "users_developers" where "users_developers"."userId" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ?',
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('insert (on conflict do nothing)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoNothing({ target: users.first_name })
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (null, ?, ?, ?) on conflict ("users"."firstName") do nothing returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('insert (on conflict do update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.first_name, set: { age: 31 } })
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (null, ?, ?, ?) on conflict ("users"."firstName") do update set "AGE" = ? returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30, 31],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "firstName" = ?, "lastName" = ?, "AGE" = ? where "users"."id" = ? returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = ? returning "firstName", "AGE"',
+			params: [1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+});

drizzle-orm/tests/casing/sqlite-to-snake.test.ts

@@ -0,0 +1,246 @@
+import Database from 'better-sqlite3';
+import { beforeEach, describe, it } from 'vitest';
+import { drizzle } from '~/better-sqlite3';
+import { relations } from '~/relations';
+import { asc, eq, sql } from '~/sql';
+import { alias, integer, sqliteTable, text, union } from '~/sqlite-core';
+
+const users = sqliteTable('users', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	firstName: text().notNull(),
+	lastName: text().notNull(),
+	// Test that custom aliases remain
+	age: integer('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = sqliteTable('developers', {
+	userId: integer().primaryKey().references(() => users.id),
+	usesDrizzleORM: integer({ mode: 'boolean' }).notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.userId],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle(new Database(':memory:'), { schema, casing: 'snake_case' });
+
+const usersCache = {
+	'public.users.id': 'id',
+	'public.users.firstName': 'first_name',
+	'public.users.lastName': 'last_name',
+	'public.users.AGE': 'age',
+};
+const developersCache = {
+	'public.developers.userId': 'user_id',
+	'public.developers.usesDrizzleORM': 'uses_drizzle_orm',
+};
+const cache = {
+	...usersCache,
+	...developersCache,
+};
+
+const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
+
+describe('sqlite to camel case', () => {
+	beforeEach(() => {
+		db.dialect.casing.clearCache();
+	});
+
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" from "users" left join "developers" on "users"."id" = "developers"."user_id" order by "users"."first_name" asc',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.userId));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "users"."first_name" from "users" left join "developers" "devs" on "users"."id" = "devs"."user_id"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.union(db.select({ firstName: users.firstName }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "first_name" from "users" union select "first_name" from "users"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.firstName }).from(users),
+			db.select({ firstName: users.firstName }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "first_name" from "users" union select "first_name" from "users"',
+			params: [],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db.query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "id", "AGE", "first_name" || \' \' || "last_name" as "name", (select json_array("uses_drizzle_orm") as "data" from (select * from "developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ? limit ?',
+			params: [1, 1, 1],
+			typings: ['none', 'none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db.query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "id", "AGE", "first_name" || \' \' || "last_name" as "name", (select json_array("uses_drizzle_orm") as "data" from (select * from "developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ?',
+			params: [1, 1],
+			typings: ['none', 'none'],
+		});
+		expect(db.dialect.casing.cache).toEqual(cache);
+	});
+
+	it('insert (on conflict do nothing)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoNothing({ target: users.firstName })
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (null, ?, ?, ?) on conflict ("users"."first_name") do nothing returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('insert (on conflict do update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.firstName, set: { age: 31 } })
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (null, ?, ?, ?) on conflict ("users"."first_name") do update set "AGE" = ? returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30, 31],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "first_name" = ?, "last_name" = ?, "AGE" = ? where "users"."id" = ? returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = ? returning "first_name", "AGE"',
+			params: [1],
+		});
+		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+});