[BigQuery]: Add BigQuery dialect and driver support

drizzle-orm/package.json

@@ -59,20 +59,20 @@
 		"@types/better-sqlite3": "*",
 		"@types/pg": "*",
 		"@types/sql.js": "*",
+		"@upstash/redis": ">=1.34.7",
 		"@vercel/postgres": ">=0.8.0",
 		"@xata.io/client": "*",
 		"better-sqlite3": ">=7",
 		"bun-types": "*",
 		"expo-sqlite": ">=14.0.0",
+		"gel": ">=2",
 		"knex": "*",
 		"kysely": "*",
 		"mysql2": ">=2",
 		"pg": ">=8",
 		"postgres": ">=3",
 		"sql.js": ">=1",
-		"sqlite3": ">=5",
-		"gel": ">=2",
-		"@upstash/redis": ">=1.34.7"
+		"sqlite3": ">=5"
 	},
 	"peerDependenciesMeta": {
 		"mysql2": {
@@ -167,6 +167,7 @@
 		"@aws-sdk/client-rds-data": "^3.549.0",
 		"@cloudflare/workers-types": "^4.20241112.0",
 		"@electric-sql/pglite": "^0.2.12",
+		"@google-cloud/bigquery": "^8.1.1",
 		"@libsql/client": "^0.10.0",
 		"@libsql/client-wasm": "^0.10.0",
 		"@miniflare/d1": "^2.14.4",

drizzle-orm/src/bigquery-core/alias.ts

@@ -0,0 +1,12 @@
+import { TableAliasProxyHandler } from '~/alias.ts';
+import type { BuildAliasTable } from './query-builders/select.types.ts';
+
+import type { BigQueryTable } from './table.ts';
+import type { BigQueryViewBase } from './view-base.ts';
+
+export function alias<TTable extends BigQueryTable | BigQueryViewBase, TAlias extends string>(
+	table: TTable,
+	alias: TAlias,
+): BuildAliasTable<TTable, TAlias> {
+	return new Proxy(table, new TableAliasProxyHandler(alias, false)) as any;
+}

drizzle-orm/src/bigquery-core/checks.ts

@@ -0,0 +1,32 @@
+import { entityKind } from '~/entity.ts';
+import type { SQL } from '~/sql/sql.ts';
+import type { BigQueryTable } from './table.ts';
+
+export class CheckBuilder {
+	static readonly [entityKind]: string = 'BigQueryCheckBuilder';
+
+	protected brand!: 'BigQueryConstraintBuilder';
+
+	constructor(public name: string, public value: SQL) {}
+
+	/** @internal */
+	build(table: BigQueryTable): Check {
+		return new Check(table, this);
+	}
+}
+
+export class Check {
+	static readonly [entityKind]: string = 'BigQueryCheck';
+
+	readonly name: string;
+	readonly value: SQL;
+
+	constructor(public table: BigQueryTable, builder: CheckBuilder) {
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+}
+
+export function check(name: string, value: SQL): CheckBuilder {
+	return new CheckBuilder(name, value);
+}

drizzle-orm/src/bigquery-core/columns/all.ts

@@ -0,0 +1,34 @@
+import { bool } from './bool.ts';
+import { bytes } from './bytes.ts';
+import { date } from './date.ts';
+import { datetime } from './datetime.ts';
+import { float64 } from './float64.ts';
+import { geography } from './geography.ts';
+import { int64 } from './int64.ts';
+import { interval } from './interval.ts';
+import { json } from './json.ts';
+import { bignumeric, numeric } from './numeric.ts';
+import { string } from './string.ts';
+import { time } from './time.ts';
+import { timestamp } from './timestamp.ts';
+
+export function getBigQueryColumnBuilders() {
+	return {
+		bool,
+		bytes,
+		date,
+		datetime,
+		float64,
+		geography,
+		int64,
+		interval,
+		json,
+		numeric,
+		bignumeric,
+		string,
+		time,
+		timestamp,
+	};
+}
+
+export type BigQueryColumnBuilders = ReturnType<typeof getBigQueryColumnBuilders>;

drizzle-orm/src/bigquery-core/columns/bool.ts

@@ -0,0 +1,48 @@
+import type { AnyBigQueryTable } from '~/bigquery-core/table.ts';
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { BigQueryColumn, BigQueryColumnBuilder } from './common.ts';
+
+export type BigQueryBoolBuilderInitial<TName extends string> = BigQueryBoolBuilder<{
+	name: TName;
+	dataType: 'boolean';
+	columnType: 'BigQueryBool';
+	data: boolean;
+	driverParam: boolean;
+	enumValues: undefined;
+}>;
+
+export class BigQueryBoolBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'BigQueryBool'>>
+	extends BigQueryColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'BigQueryBoolBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'boolean', 'BigQueryBool');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyBigQueryTable<{ name: TTableName }>,
+	): BigQueryBool<MakeColumnConfig<T, TTableName>> {
+		return new BigQueryBool<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class BigQueryBool<T extends ColumnBaseConfig<'boolean', 'BigQueryBool'>> extends BigQueryColumn<T> {
+	static override readonly [entityKind]: string = 'BigQueryBool';
+
+	getSQLType(): string {
+		return 'BOOL';
+	}
+}
+
+export function bool(): BigQueryBoolBuilderInitial<''>;
+export function bool<TName extends string>(name: TName): BigQueryBoolBuilderInitial<TName>;
+export function bool(name?: string) {
+	return new BigQueryBoolBuilder(name ?? '');
+}

drizzle-orm/src/bigquery-core/columns/bytes.ts

@@ -0,0 +1,81 @@
+import type { AnyBigQueryTable } from '~/bigquery-core/table.ts';
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { BigQueryColumn, BigQueryColumnBuilder } from './common.ts';
+
+export type BigQueryBytesBuilderInitial<TName extends string> = BigQueryBytesBuilder<{
+	name: TName;
+	dataType: 'buffer';
+	columnType: 'BigQueryBytes';
+	data: Buffer;
+	driverParam: Buffer | Uint8Array | string;
+	enumValues: undefined;
+}>;
+
+export class BigQueryBytesBuilder<T extends ColumnBuilderBaseConfig<'buffer', 'BigQueryBytes'>>
+	extends BigQueryColumnBuilder<T, { length: number | undefined }>
+{
+	static override readonly [entityKind]: string = 'BigQueryBytesBuilder';
+
+	constructor(name: T['name'], length?: number) {
+		super(name, 'buffer', 'BigQueryBytes');
+		this.config.length = length;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyBigQueryTable<{ name: TTableName }>,
+	): BigQueryBytes<MakeColumnConfig<T, TTableName>> {
+		return new BigQueryBytes<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class BigQueryBytes<T extends ColumnBaseConfig<'buffer', 'BigQueryBytes'>>
+	extends BigQueryColumn<T, { length: number | undefined }>
+{
+	static override readonly [entityKind]: string = 'BigQueryBytes';
+
+	readonly length: number | undefined = this.config.length;
+
+	getSQLType(): string {
+		return this.length === undefined ? 'BYTES' : `BYTES(${this.length})`;
+	}
+
+	override mapFromDriverValue(value: string | Buffer | Uint8Array): Buffer {
+		if (typeof value === 'string') {
+			// BigQuery returns base64-encoded bytes
+			return Buffer.from(value, 'base64');
+		}
+		if (value instanceof Uint8Array) {
+			return Buffer.from(value);
+		}
+		return value;
+	}
+
+	override mapToDriverValue(value: Buffer | Uint8Array): string {
+		// Convert to base64 for BigQuery
+		return Buffer.from(value).toString('base64');
+	}
+}
+
+export interface BigQueryBytesConfig {
+	length?: number;
+}
+
+export function bytes(): BigQueryBytesBuilderInitial<''>;
+export function bytes<TName extends string>(name: TName): BigQueryBytesBuilderInitial<TName>;
+export function bytes(config: BigQueryBytesConfig): BigQueryBytesBuilderInitial<''>;
+export function bytes<TName extends string>(
+	name: TName,
+	config: BigQueryBytesConfig,
+): BigQueryBytesBuilderInitial<TName>;
+export function bytes(a?: string | BigQueryBytesConfig, b?: BigQueryBytesConfig) {
+	if (typeof a === 'object') {
+		return new BigQueryBytesBuilder('', a.length);
+	}
+	return new BigQueryBytesBuilder(a ?? '', b?.length);
+}