@xata.io/drizzle 0.0.0-alpha.ve565538 → 0.0.0-alpha.ve69ec6a

package/test/integration.ava.ts

@@ -0,0 +1,2187 @@
+import { getHostUrl, parseProviderString, XataApiClient } from '@xata.io/client';
+import type { TestFn } from 'ava';
+import anyTest from 'ava';
+import dotenv from 'dotenv';
+import {
+  and,
+  asc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  lt,
+  name,
+  placeholder,
+  sql,
+  TransactionRollbackError,
+  type SQL,
+  type SQLWrapper
+} from 'drizzle-orm';
+import {
+  alias,
+  boolean,
+  char,
+  cidr,
+  getMaterializedViewConfig,
+  getViewConfig,
+  inet,
+  integer,
+  jsonb,
+  macaddr,
+  macaddr8,
+  pgEnum,
+  pgMaterializedView,
+  pgTable,
+  pgTableCreator,
+  uuid as pgUuid,
+  pgView,
+  serial,
+  text,
+  timestamp,
+  varchar,
+  type PgColumn
+} from 'drizzle-orm/pg-core';
+import { migrate } from 'drizzle-orm/vercel-postgres/migrator';
+import fetch from 'node-fetch';
+import { join } from 'path';
+import { v4 as uuid } from 'uuid';
+import { drizzle, type XataDatabase } from '../src';
+import { Expect, type Equal } from './utils';
+import { tables, XataClient } from './xata.codegen';
+
+const ENABLE_LOGGING = false;
+
+// Get environment variables before reading them
+dotenv.config({ path: join(process.cwd(), '.env') });
+
+const apiKey = process.env.XATA_API_KEY ?? '';
+if (apiKey === '') throw new Error('XATA_API_KEY environment variable is not set');
+
+const workspace = process.env.XATA_WORKSPACE ?? '';
+if (workspace === '') throw new Error('XATA_WORKSPACE environment variable is not set');
+
+const region = process.env.XATA_REGION || 'eu-west-1';
+
+const host = parseProviderString(process.env.XATA_API_PROVIDER);
+if (host === null) {
+  throw new Error(
+    `Invalid XATA_API_PROVIDER environment variable, expected either "production", "staging" or "apiUrl,workspacesUrl"`
+  );
+}
+
+const usersTable = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  verified: boolean('verified').notNull().default(false),
+  jsonb: jsonb('jsonb').$type<string[]>(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow()
+});
+
+const citiesTable = pgTable('cities', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  state: char('state', { length: 2 })
+});
+
+const users2Table = pgTable('users2', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  cityId: integer('city_id').references(() => citiesTable.id)
+});
+
+const coursesTable = pgTable('courses', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  categoryId: integer('category_id').references(() => courseCategoriesTable.id)
+});
+
+const courseCategoriesTable = pgTable('course_categories', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull()
+});
+
+const orders = pgTable('orders', {
+  id: serial('id').primaryKey(),
+  region: text('region').notNull(),
+  product: text('product').notNull(),
+  amount: integer('amount').notNull(),
+  quantity: integer('quantity').notNull()
+});
+
+const network = pgTable('network_table', {
+  inet: inet('inet').notNull(),
+  cidr: cidr('cidr').notNull(),
+  macaddr: macaddr('macaddr').notNull(),
+  macaddr8: macaddr8('macaddr8').notNull()
+});
+
+const salEmp = pgTable('sal_emp', {
+  name: text('name'),
+  payByQuarter: integer('pay_by_quarter').array(),
+  schedule: text('schedule').array().array()
+});
+
+const _tictactoe = pgTable('tictactoe', {
+  squares: integer('squares').array(3).array(3)
+});
+
+const usersMigratorTable = pgTable('users12', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull()
+});
+
+interface Context {
+  id: string;
+  db: XataDatabase;
+  client: XataClient;
+  api: XataApiClient;
+}
+
+const test = anyTest as TestFn<Context>;
+
+test.before(async (t) => {
+  const ctx = t.context;
+  ctx.api = new XataApiClient({ apiKey, fetch, host, clientName: 'sdk-tests' });
+});
+
+test.beforeEach(async (t) => {
+  const ctx = t.context;
+  ctx.id = Date.now().toString(36);
+
+  const { databaseName: database } = await ctx.api.database.createDatabase({
+    workspace,
+    database: `sdk-integration-test-drizzle-${ctx.id}`,
+    data: { region },
+    headers: { 'X-Xata-Files': 'true' }
+  });
+
+  const { edits } = await ctx.api.migrations.compareBranchWithUserSchema({
+    workspace,
+    region,
+    database,
+    branch: 'main',
+    schema: { tables: tables as any }
+  });
+
+  await ctx.api.migrations.applyBranchSchemaEdit({ workspace, region, database, branch: 'main', edits });
+
+  const workspaceUrl = getHostUrl(host, 'workspaces').replace('{workspaceId}', workspace).replace('{region}', region);
+
+  ctx.client = new XataClient({
+    databaseURL: `${workspaceUrl}/db/${database}`,
+    branch: 'main',
+    apiKey,
+    fetch,
+    clientName: 'sdk-tests'
+  });
+
+  ctx.db = drizzle(ctx.client, { logger: ENABLE_LOGGING });
+});
+
+test.afterEach.always(async (t) => {
+  const ctx = t.context;
+
+  await ctx.api.database.deleteDatabase({ workspace, database: `sdk-integration-test-drizzle-${ctx.id}` });
+});
+
+test.skip('select all fields', async (t) => {
+  const { db } = t.context;
+
+  const now = Date.now();
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const result = await db.select().from(usersTable);
+
+  t.assert(result[0]!.createdAt instanceof Date);
+  t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 100);
+  t.deepEqual(result, [{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.skip('select sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db
+    .select({
+      name: sql`upper(${usersTable.name})`
+    })
+    .from(usersTable);
+
+  t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.skip('select typed sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+
+  const users = await db
+    .select({
+      name: sql<string>`upper(${usersTable.name})`
+    })
+    .from(usersTable);
+
+  t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.skip('select distinct', async (t) => {
+  const { db } = t.context;
+
+  const usersDistinctTable = pgTable('users_distinct', {
+    id: integer('id').notNull(),
+    name: text('name').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+  await db.execute(sql`create table ${usersDistinctTable} (id integer, name text)`);
+
+  await db.insert(usersDistinctTable).values([
+    { id: 1, name: 'John' },
+    { id: 1, name: 'John' },
+    { id: 2, name: 'John' },
+    { id: 1, name: 'Jane' }
+  ]);
+  const users1 = await db
+    .selectDistinct()
+    .from(usersDistinctTable)
+    .orderBy(usersDistinctTable.id, usersDistinctTable.name);
+  const users2 = await db
+    .selectDistinctOn([usersDistinctTable.id])
+    .from(usersDistinctTable)
+    .orderBy(usersDistinctTable.id);
+  const users3 = await db
+    .selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name })
+    .from(usersDistinctTable)
+    .orderBy(usersDistinctTable.name);
+
+  await db.execute(sql`drop table ${usersDistinctTable}`);
+
+  t.deepEqual(users1, [
+    { id: 1, name: 'Jane' },
+    { id: 1, name: 'John' },
+    { id: 2, name: 'John' }
+  ]);
+
+  t.deepEqual(users2.length, 2);
+  t.deepEqual(users2[0]?.id, 1);
+  t.deepEqual(users2[1]?.id, 2);
+
+  t.deepEqual(users3.length, 2);
+  t.deepEqual(users3[0]?.name, 'Jane');
+  t.deepEqual(users3[1]?.name, 'John');
+});
+
+test.skip('insert returning sql', async (t) => {
+  const { db } = t.context;
+
+  const users = await db
+    .insert(usersTable)
+    .values({ name: 'John' })
+    .returning({
+      name: sql`upper(${usersTable.name})`
+    });
+
+  t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.skip('delete returning sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db
+    .delete(usersTable)
+    .where(eq(usersTable.name, 'John'))
+    .returning({
+      name: sql`upper(${usersTable.name})`
+    });
+
+  t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.skip('update returning sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db
+    .update(usersTable)
+    .set({ name: 'Jane' })
+    .where(eq(usersTable.name, 'John'))
+    .returning({
+      name: sql`upper(${usersTable.name})`
+    });
+
+  t.deepEqual(users, [{ name: 'JANE' }]);
+});
+
+test.skip('update with returning all fields', async (t) => {
+  const { db } = t.context;
+
+  const now = Date.now();
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning();
+
+  t.assert(users[0]!.createdAt instanceof Date);
+  t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
+  t.deepEqual(users, [{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+});
+
+test.skip('update with returning partial', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
+    id: usersTable.id,
+    name: usersTable.name
+  });
+
+  t.deepEqual(users, [{ id: 1, name: 'Jane' }]);
+});
+
+test.skip('delete with returning all fields', async (t) => {
+  const { db } = t.context;
+
+  const now = Date.now();
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
+
+  t.assert(users[0]!.createdAt instanceof Date);
+  t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
+  t.deepEqual(users, [{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+});
+
+test.skip('delete with returning partial', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
+    id: usersTable.id,
+    name: usersTable.name
+  });
+
+  t.deepEqual(users, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('insert + select', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const result = await db.select().from(usersTable);
+  t.deepEqual(result, [{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+  await db.insert(usersTable).values({ name: 'Jane' });
+  const result2 = await db.select().from(usersTable);
+  t.deepEqual(result2, [
+    { id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+    { id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt }
+  ]);
+});
+
+test.skip('json insert', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+  const result = await db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name,
+      jsonb: usersTable.jsonb
+    })
+    .from(usersTable);
+
+  t.deepEqual(result, [{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test.skip('char insert', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+  const result = await db
+    .select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
+    .from(citiesTable);
+
+  t.deepEqual(result, [{ id: 1, name: 'Austin', state: 'TX' }]);
+});
+
+test.skip('char update', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+  await db.update(citiesTable).set({ name: 'Atlanta', state: 'GA' }).where(eq(citiesTable.id, 1));
+  const result = await db
+    .select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
+    .from(citiesTable);
+
+  t.deepEqual(result, [{ id: 1, name: 'Atlanta', state: 'GA' }]);
+});
+
+test.skip('char delete', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+  await db.delete(citiesTable).where(eq(citiesTable.state, 'TX'));
+  const result = await db
+    .select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
+    .from(citiesTable);
+
+  t.deepEqual(result, []);
+});
+
+test.skip('insert with overridden default values', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John', verified: true });
+  const result = await db.select().from(usersTable);
+
+  t.deepEqual(result, [{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.skip('insert many', async (t) => {
+  const { db } = t.context;
+
+  await db
+    .insert(usersTable)
+    .values([
+      { name: 'John' },
+      { name: 'Bruce', jsonb: ['foo', 'bar'] },
+      { name: 'Jane' },
+      { name: 'Austin', verified: true }
+    ]);
+  const result = await db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name,
+      jsonb: usersTable.jsonb,
+      verified: usersTable.verified
+    })
+    .from(usersTable);
+
+  t.deepEqual(result, [
+    { id: 1, name: 'John', jsonb: null, verified: false },
+    { id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+    { id: 3, name: 'Jane', jsonb: null, verified: false },
+    { id: 4, name: 'Austin', jsonb: null, verified: true }
+  ]);
+});
+
+test.skip('insert many with returning', async (t) => {
+  const { db } = t.context;
+
+  const result = await db
+    .insert(usersTable)
+    .values([
+      { name: 'John' },
+      { name: 'Bruce', jsonb: ['foo', 'bar'] },
+      { name: 'Jane' },
+      { name: 'Austin', verified: true }
+    ])
+    .returning({
+      id: usersTable.id,
+      name: usersTable.name,
+      jsonb: usersTable.jsonb,
+      verified: usersTable.verified
+    });
+
+  t.deepEqual(result, [
+    { id: 1, name: 'John', jsonb: null, verified: false },
+    { id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+    { id: 3, name: 'Jane', jsonb: null, verified: false },
+    { id: 4, name: 'Austin', jsonb: null, verified: true }
+  ]);
+});
+
+test.skip('select with group by as field', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+  const result = await db.select({ name: usersTable.name }).from(usersTable).groupBy(usersTable.name);
+
+  t.deepEqual(result, [{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test.skip('select with group by as sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+  const result = await db
+    .select({ name: usersTable.name })
+    .from(usersTable)
+    .groupBy(sql`${usersTable.name}`);
+
+  t.deepEqual(result, [{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test.skip('select with group by as sql + column', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+  const result = await db
+    .select({ name: usersTable.name })
+    .from(usersTable)
+    .groupBy(sql`${usersTable.name}`, usersTable.id);
+
+  t.deepEqual(result, [{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
+});
+
+test.skip('select with group by as column + sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+  const result = await db
+    .select({ name: usersTable.name })
+    .from(usersTable)
+    .groupBy(usersTable.id, sql`${usersTable.name}`);
+
+  t.deepEqual(result, [{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
+});
+
+test.skip('select with group by complex query', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+  const result = await db
+    .select({ name: usersTable.name })
+    .from(usersTable)
+    .groupBy(usersTable.id, sql`${usersTable.name}`)
+    .orderBy(asc(usersTable.name))
+    .limit(1);
+
+  t.deepEqual(result, [{ name: 'Jane' }]);
+});
+
+test('build query', async (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .select({ id: usersTable.id, name: usersTable.name })
+    .from(usersTable)
+    .groupBy(usersTable.id, usersTable.name)
+    .toSQL();
+
+  t.deepEqual(query, {
+    sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+    params: []
+  });
+});
+
+test.skip('insert sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: sql`${'John'}` });
+  const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+  t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('partial join with alias', async (t) => {
+  const { db } = t.context;
+  const customerAlias = alias(usersTable, 'customer');
+
+  await db.insert(usersTable).values([
+    { id: 10, name: 'Ivan' },
+    { id: 11, name: 'Hans' }
+  ]);
+  const result = await db
+    .select({
+      user: {
+        id: usersTable.id,
+        name: usersTable.name
+      },
+      customer: {
+        id: customerAlias.id,
+        name: customerAlias.name
+      }
+    })
+    .from(usersTable)
+    .leftJoin(customerAlias, eq(customerAlias.id, 11))
+    .where(eq(usersTable.id, 10));
+
+  t.deepEqual(result, [
+    {
+      user: { id: 10, name: 'Ivan' },
+      customer: { id: 11, name: 'Hans' }
+    }
+  ]);
+});
+
+test.skip('full join with alias', async (t) => {
+  const { db } = t.context;
+
+  const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+  const users = pgTable('users', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+  await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+  const customers = alias(users, 'customer');
+
+  await db.insert(users).values([
+    { id: 10, name: 'Ivan' },
+    { id: 11, name: 'Hans' }
+  ]);
+  const result = await db.select().from(users).leftJoin(customers, eq(customers.id, 11)).where(eq(users.id, 10));
+
+  t.deepEqual(result, [
+    {
+      users: {
+        id: 10,
+        name: 'Ivan'
+      },
+      customer: {
+        id: 11,
+        name: 'Hans'
+      }
+    }
+  ]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('select from alias', async (t) => {
+  const { db } = t.context;
+
+  const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+  const users = pgTable('users', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+  await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+  const user = alias(users, 'user');
+  const customers = alias(users, 'customer');
+
+  await db.insert(users).values([
+    { id: 10, name: 'Ivan' },
+    { id: 11, name: 'Hans' }
+  ]);
+  const result = await db.select().from(user).leftJoin(customers, eq(customers.id, 11)).where(eq(user.id, 10));
+
+  t.deepEqual(result, [
+    {
+      user: {
+        id: 10,
+        name: 'Ivan'
+      },
+      customer: {
+        id: 11,
+        name: 'Hans'
+      }
+    }
+  ]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('insert with spaces', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+  const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+  t.deepEqual(result, [{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test.skip('prepared statement', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const statement = db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name
+    })
+    .from(usersTable)
+    .prepare('statement1');
+  const result = await statement.execute();
+
+  t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('prepared statement reuse', async (t) => {
+  const { db } = t.context;
+
+  const stmt = db
+    .insert(usersTable)
+    .values({
+      verified: true,
+      name: placeholder('name')
+    })
+    .prepare('stmt2');
+
+  for (let i = 0; i < 10; i++) {
+    await stmt.execute({ name: `John ${i}` });
+  }
+
+  const result = await db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name,
+      verified: usersTable.verified
+    })
+    .from(usersTable);
+
+  t.deepEqual(result, [
+    { id: 1, name: 'John 0', verified: true },
+    { id: 2, name: 'John 1', verified: true },
+    { id: 3, name: 'John 2', verified: true },
+    { id: 4, name: 'John 3', verified: true },
+    { id: 5, name: 'John 4', verified: true },
+    { id: 6, name: 'John 5', verified: true },
+    { id: 7, name: 'John 6', verified: true },
+    { id: 8, name: 'John 7', verified: true },
+    { id: 9, name: 'John 8', verified: true },
+    { id: 10, name: 'John 9', verified: true }
+  ]);
+});
+
+test.skip('prepared statement with placeholder in .where', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const stmt = db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name
+    })
+    .from(usersTable)
+    .where(eq(usersTable.id, placeholder('id')))
+    .prepare('stmt3');
+  const result = await stmt.execute({ id: 1 });
+
+  t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('prepared statement with placeholder in .limit', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+  const stmt = db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name
+    })
+    .from(usersTable)
+    .where(eq(usersTable.id, placeholder('id')))
+    .limit(placeholder('limit'))
+    .prepare('stmt_limit');
+
+  const result = await stmt.execute({ id: 1, limit: 1 });
+
+  t.deepEqual(result, [{ id: 1, name: 'John' }]);
+  t.is(result.length, 1);
+});
+
+test.skip('prepared statement with placeholder in .offset', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+  const stmt = db
+    .select({
+      id: usersTable.id,
+      name: usersTable.name
+    })
+    .from(usersTable)
+    .offset(placeholder('offset'))
+    .prepare('stmt_offset');
+
+  const result = await stmt.execute({ offset: 1 });
+
+  t.deepEqual(result, [{ id: 2, name: 'John1' }]);
+});
+
+// TODO change tests to new structure
+test.skip('migrator', async (t) => {
+  const { db } = t.context;
+
+  await db.execute(sql`drop table if exists all_columns`);
+  await db.execute(sql`drop table if exists users12`);
+  await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+  await migrate(db, { migrationsFolder: './drizzle2/pg' });
+
+  await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+  const result = await db.select().from(usersMigratorTable);
+
+  t.deepEqual(result, [{ id: 1, name: 'John', email: 'email' }]);
+
+  await db.execute(sql`drop table all_columns`);
+  await db.execute(sql`drop table users12`);
+  await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+});
+
+test.skip('insert via db.execute + select via db.execute', async (t) => {
+  const { db } = t.context;
+
+  await db.execute(sql`insert into ${usersTable} (${name(usersTable.name.name)}) values (${'John'})`);
+
+  const result = await db.execute<{ id: number; name: string }>(sql`select id, name from "users"`);
+  t.deepEqual(result.rows, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('insert via db.execute + returning', async (t) => {
+  const { db } = t.context;
+
+  const inserted = await db.execute<{ id: number; name: string }>(
+    sql`insert into ${usersTable} (${name(usersTable.name.name)}) values (${'John'}) returning ${usersTable.id}, ${
+      usersTable.name
+    }`
+  );
+  t.deepEqual(inserted.rows, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('insert via db.execute w/ query builder', async (t) => {
+  const { db } = t.context;
+
+  const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+    db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name })
+  );
+  t.deepEqual(inserted.rows, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('build query insert with onConflict do update', async (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .insert(usersTable)
+    .values({ name: 'John', jsonb: ['foo', 'bar'] })
+    .onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+    .toSQL();
+
+  t.deepEqual(query, {
+    sql: 'insert into "users" ("name", "jsonb") values ($1, $2) on conflict ("id") do update set "name" = $3',
+    params: ['John', '["foo","bar"]', 'John1']
+  });
+});
+
+test.skip('build query insert with onConflict do update / multiple columns', async (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .insert(usersTable)
+    .values({ name: 'John', jsonb: ['foo', 'bar'] })
+    .onConflictDoUpdate({ target: [usersTable.id, usersTable.name], set: { name: 'John1' } })
+    .toSQL();
+
+  t.deepEqual(query, {
+    sql: 'insert into "users" ("name", "jsonb") values ($1, $2) on conflict ("id","name") do update set "name" = $3',
+    params: ['John', '["foo","bar"]', 'John1']
+  });
+});
+
+test.skip('build query insert with onConflict do nothing', async (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .insert(usersTable)
+    .values({ name: 'John', jsonb: ['foo', 'bar'] })
+    .onConflictDoNothing()
+    .toSQL();
+
+  t.deepEqual(query, {
+    sql: 'insert into "users" ("name", "jsonb") values ($1, $2) on conflict do nothing',
+    params: ['John', '["foo","bar"]']
+  });
+});
+
+test.skip('build query insert with onConflict do nothing + target', async (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .insert(usersTable)
+    .values({ name: 'John', jsonb: ['foo', 'bar'] })
+    .onConflictDoNothing({ target: usersTable.id })
+    .toSQL();
+
+  t.deepEqual(query, {
+    sql: 'insert into "users" ("name", "jsonb") values ($1, $2) on conflict ("id") do nothing',
+    params: ['John', '["foo","bar"]']
+  });
+});
+
+test.skip('insert with onConflict do update', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+
+  await db
+    .insert(usersTable)
+    .values({ id: 1, name: 'John' })
+    .onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
+
+  const res = await db
+    .select({ id: usersTable.id, name: usersTable.name })
+    .from(usersTable)
+    .where(eq(usersTable.id, 1));
+
+  t.deepEqual(res, [{ id: 1, name: 'John1' }]);
+});
+
+test.skip('insert with onConflict do nothing', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+
+  await db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing();
+
+  const res = await db
+    .select({ id: usersTable.id, name: usersTable.name })
+    .from(usersTable)
+    .where(eq(usersTable.id, 1));
+
+  t.deepEqual(res, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('insert with onConflict do nothing + target', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values({ name: 'John' });
+
+  await db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing({ target: usersTable.id });
+
+  const res = await db
+    .select({ id: usersTable.id, name: usersTable.name })
+    .from(usersTable)
+    .where(eq(usersTable.id, 1));
+
+  t.deepEqual(res, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('left join (flat object fields)', async (t) => {
+  const { db } = t.context;
+
+  const { id: cityId } = await db
+    .insert(citiesTable)
+    .values([{ name: 'Paris' }, { name: 'London' }])
+    .returning({ id: citiesTable.id })
+    .then((rows) => rows[0]!);
+
+  await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+  const res = await db
+    .select({
+      userId: users2Table.id,
+      userName: users2Table.name,
+      cityId: citiesTable.id,
+      cityName: citiesTable.name
+    })
+    .from(users2Table)
+    .leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+  t.deepEqual(res, [
+    { userId: 1, userName: 'John', cityId, cityName: 'Paris' },
+    { userId: 2, userName: 'Jane', cityId: null, cityName: null }
+  ]);
+});
+
+test.skip('left join (grouped fields)', async (t) => {
+  const { db } = t.context;
+
+  const { id: cityId } = await db
+    .insert(citiesTable)
+    .values([{ name: 'Paris' }, { name: 'London' }])
+    .returning({ id: citiesTable.id })
+    .then((rows) => rows[0]!);
+
+  await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+  const res = await db
+    .select({
+      id: users2Table.id,
+      user: {
+        name: users2Table.name,
+        nameUpper: sql<string>`upper(${users2Table.name})`
+      },
+      city: {
+        id: citiesTable.id,
+        name: citiesTable.name,
+        nameUpper: sql<string>`upper(${citiesTable.name})`
+      }
+    })
+    .from(users2Table)
+    .leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+  t.deepEqual(res, [
+    {
+      id: 1,
+      user: { name: 'John', nameUpper: 'JOHN' },
+      city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' }
+    },
+    {
+      id: 2,
+      user: { name: 'Jane', nameUpper: 'JANE' },
+      city: null
+    }
+  ]);
+});
+
+test.skip('left join (all fields)', async (t) => {
+  const { db } = t.context;
+
+  const { id: cityId } = await db
+    .insert(citiesTable)
+    .values([{ name: 'Paris' }, { name: 'London' }])
+    .returning({ id: citiesTable.id })
+    .then((rows) => rows[0]!);
+
+  await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+  const res = await db.select().from(users2Table).leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+  t.deepEqual(res, [
+    {
+      users2: {
+        id: 1,
+        name: 'John',
+        cityId
+      },
+      cities: {
+        id: cityId,
+        name: 'Paris',
+        state: null
+      }
+    },
+    {
+      users2: {
+        id: 2,
+        name: 'Jane',
+        cityId: null
+      },
+      cities: null
+    }
+  ]);
+});
+
+test.skip('join subquery', async (t) => {
+  const { db } = t.context;
+
+  await db
+    .insert(courseCategoriesTable)
+    .values([{ name: 'Category 1' }, { name: 'Category 2' }, { name: 'Category 3' }, { name: 'Category 4' }]);
+
+  await db.insert(coursesTable).values([
+    { name: 'Development', categoryId: 2 },
+    { name: 'IT & Software', categoryId: 3 },
+    { name: 'Marketing', categoryId: 4 },
+    { name: 'Design', categoryId: 1 }
+  ]);
+
+  const sq2 = db
+    .select({
+      categoryId: courseCategoriesTable.id,
+      category: courseCategoriesTable.name,
+      total: sql<number>`count(${courseCategoriesTable.id})`
+    })
+    .from(courseCategoriesTable)
+    .groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+    .as('sq2');
+
+  const res = await db
+    .select({
+      courseName: coursesTable.name,
+      categoryId: sq2.categoryId
+    })
+    .from(coursesTable)
+    .leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+    .orderBy(coursesTable.name);
+
+  t.deepEqual(res, [
+    { courseName: 'Design', categoryId: 1 },
+    { courseName: 'Development', categoryId: 2 },
+    { courseName: 'IT & Software', categoryId: 3 },
+    { courseName: 'Marketing', categoryId: 4 }
+  ]);
+});
+
+test.skip('with ... select', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(orders).values([
+    { region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+    { region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+    { region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+    { region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+    { region: 'US', product: 'A', amount: 30, quantity: 3 },
+    { region: 'US', product: 'A', amount: 40, quantity: 4 },
+    { region: 'US', product: 'B', amount: 40, quantity: 4 },
+    { region: 'US', product: 'B', amount: 50, quantity: 5 }
+  ]);
+
+  const regionalSales = db.$with('regional_sales').as(
+    db
+      .select({
+        region: orders.region,
+        totalSales: sql<number>`sum(${orders.amount})`.as('total_sales')
+      })
+      .from(orders)
+      .groupBy(orders.region)
+  );
+
+  const topRegions = db.$with('top_regions').as(
+    db
+      .select({
+        region: regionalSales.region
+      })
+      .from(regionalSales)
+      .where(
+        gt(regionalSales.totalSales, db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales))
+      )
+  );
+
+  const result = await db
+    .with(regionalSales, topRegions)
+    .select({
+      region: orders.region,
+      product: orders.product,
+      productUnits: sql<number>`sum(${orders.quantity})::int`,
+      productSales: sql<number>`sum(${orders.amount})::int`
+    })
+    .from(orders)
+    .where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+    .groupBy(orders.region, orders.product)
+    .orderBy(orders.region, orders.product);
+
+  t.deepEqual(result, [
+    {
+      region: 'Europe',
+      product: 'A',
+      productUnits: 3,
+      productSales: 30
+    },
+    {
+      region: 'Europe',
+      product: 'B',
+      productUnits: 5,
+      productSales: 50
+    },
+    {
+      region: 'US',
+      product: 'A',
+      productUnits: 7,
+      productSales: 70
+    },
+    {
+      region: 'US',
+      product: 'B',
+      productUnits: 9,
+      productSales: 90
+    }
+  ]);
+});
+
+test.skip('select from subquery sql', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
+
+  const sq = db
+    .select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
+    .from(users2Table)
+    .as('sq');
+
+  const res = await db.select({ name: sq.name }).from(sq);
+
+  t.deepEqual(res, [{ name: 'John modified' }, { name: 'Jane modified' }]);
+});
+
+test('select a field without joining its table', (t) => {
+  const { db } = t.context;
+
+  t.throws(() => db.select({ name: users2Table.name }).from(usersTable).prepare('query'));
+});
+
+test('select all fields from subquery without alias', (t) => {
+  const { db } = t.context;
+
+  const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+  t.throws(() => db.select().from(sq).prepare('query'));
+});
+
+test.skip('select count()', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+  const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+  t.deepEqual(res, [{ count: '2' }]);
+});
+
+test.skip('select count w/ custom mapper', async (t) => {
+  const { db } = t.context;
+
+  function count(value: PgColumn | SQLWrapper): SQL<number>;
+  function count(value: PgColumn | SQLWrapper, alias: string): SQL.Aliased<number>;
+  function count(value: PgColumn | SQLWrapper, alias?: string): SQL<number> | SQL.Aliased<number> {
+    const result = sql`count(${value})`.mapWith(Number);
+    if (!alias) {
+      return result;
+    }
+    return result.as(alias);
+  }
+
+  await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+  const res = await db.select({ count: count(sql`*`) }).from(usersTable);
+
+  t.deepEqual(res, [{ count: 2 }]);
+});
+
+test.skip('network types', async (t) => {
+  const { db } = t.context;
+
+  const value: typeof network.$inferSelect = {
+    inet: '127.0.0.1',
+    cidr: '192.168.100.128/25',
+    macaddr: '08:00:2b:01:02:03',
+    macaddr8: '08:00:2b:01:02:03:04:05'
+  };
+
+  await db.insert(network).values(value);
+
+  const res = await db.select().from(network);
+
+  t.deepEqual(res, [value]);
+});
+
+test.skip('array types', async (t) => {
+  const { db } = t.context;
+
+  const values: (typeof salEmp.$inferSelect)[] = [
+    {
+      name: 'John',
+      payByQuarter: [10000, 10000, 10000, 10000],
+      schedule: [
+        ['meeting', 'lunch'],
+        ['training', 'presentation']
+      ]
+    },
+    {
+      name: 'Carol',
+      payByQuarter: [20000, 25000, 25000, 25000],
+      schedule: [
+        ['breakfast', 'consulting'],
+        ['meeting', 'lunch']
+      ]
+    }
+  ];
+
+  await db.insert(salEmp).values(values);
+
+  const res = await db.select().from(salEmp);
+
+  t.deepEqual(res, values);
+});
+
+test('select for ...', (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .select()
+    .from(users2Table)
+    .for('update')
+    .for('no key update', { of: users2Table })
+    .for('no key update', { of: users2Table, skipLocked: true })
+    .for('share', { of: users2Table, noWait: true })
+    .toSQL();
+
+  t.regex(
+    query.sql,
+    / for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait$/
+  );
+});
+
+test.skip('having', async (t) => {
+  const { db } = t.context;
+
+  await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+  await db.insert(users2Table).values([
+    { name: 'John', cityId: 1 },
+    { name: 'Jane', cityId: 1 },
+    {
+      name: 'Jack',
+      cityId: 2
+    }
+  ]);
+
+  const result = await db
+    .select({
+      id: citiesTable.id,
+      name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+      usersCount: sql<number>`count(${users2Table.id})::int`.as('users_count')
+    })
+    .from(citiesTable)
+    .leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+    .where(({ name }) => sql`length(${name}) >= 3`)
+    .groupBy(citiesTable.id)
+    .having(({ usersCount }) => sql`${usersCount} > 0`)
+    .orderBy(({ name }) => name);
+
+  t.deepEqual(result, [
+    {
+      id: 1,
+      name: 'LONDON',
+      usersCount: 2
+    },
+    {
+      id: 2,
+      name: 'PARIS',
+      usersCount: 1
+    }
+  ]);
+});
+
+test.skip('view', async (t) => {
+  const { db } = t.context;
+
+  const newYorkers1 = pgView('new_yorkers').as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+  const newYorkers2 = pgView('new_yorkers', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  }).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+  const newYorkers3 = pgView('new_yorkers', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  }).existing();
+
+  await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
+
+  await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+  await db.insert(users2Table).values([
+    { name: 'John', cityId: 1 },
+    { name: 'Jane', cityId: 1 },
+    { name: 'Jack', cityId: 2 }
+  ]);
+
+  {
+    const result = await db.select().from(newYorkers1);
+    t.deepEqual(result, [
+      { id: 1, name: 'John', cityId: 1 },
+      { id: 2, name: 'Jane', cityId: 1 }
+    ]);
+  }
+
+  {
+    const result = await db.select().from(newYorkers2);
+    t.deepEqual(result, [
+      { id: 1, name: 'John', cityId: 1 },
+      { id: 2, name: 'Jane', cityId: 1 }
+    ]);
+  }
+
+  {
+    const result = await db.select().from(newYorkers3);
+    t.deepEqual(result, [
+      { id: 1, name: 'John', cityId: 1 },
+      { id: 2, name: 'Jane', cityId: 1 }
+    ]);
+  }
+
+  {
+    const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+    t.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }]);
+  }
+
+  await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test.skip('materialized view', async (t) => {
+  const { db } = t.context;
+
+  const newYorkers1 = pgMaterializedView('new_yorkers').as((qb) =>
+    qb.select().from(users2Table).where(eq(users2Table.cityId, 1))
+  );
+
+  const newYorkers2 = pgMaterializedView('new_yorkers', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  }).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+  const newYorkers3 = pgMaterializedView('new_yorkers', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  }).existing();
+
+  await db.execute(sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`);
+
+  await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+  await db.insert(users2Table).values([
+    { name: 'John', cityId: 1 },
+    { name: 'Jane', cityId: 1 },
+    { name: 'Jack', cityId: 2 }
+  ]);
+
+  {
+    const result = await db.select().from(newYorkers1);
+    t.deepEqual(result, []);
+  }
+
+  await db.refreshMaterializedView(newYorkers1);
+
+  {
+    const result = await db.select().from(newYorkers1);
+    t.deepEqual(result, [
+      { id: 1, name: 'John', cityId: 1 },
+      { id: 2, name: 'Jane', cityId: 1 }
+    ]);
+  }
+
+  {
+    const result = await db.select().from(newYorkers2);
+    t.deepEqual(result, [
+      { id: 1, name: 'John', cityId: 1 },
+      { id: 2, name: 'Jane', cityId: 1 }
+    ]);
+  }
+
+  {
+    const result = await db.select().from(newYorkers3);
+    t.deepEqual(result, [
+      { id: 1, name: 'John', cityId: 1 },
+      { id: 2, name: 'Jane', cityId: 1 }
+    ]);
+  }
+
+  {
+    const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+    t.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }]);
+  }
+
+  await db.execute(sql`drop materialized view ${newYorkers1}`);
+});
+
+// TODO: copy to SQLite and MySQL, add to docs
+test('select from raw sql', async (t) => {
+  const { db } = t.context;
+
+  const result = await db
+    .select({
+      id: sql<number>`id`,
+      name: sql<string>`name`
+    })
+    .from(sql`(select 1 as id, 'John' as name) as users`);
+
+  Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+  t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.skip('select from raw sql with joins', async (t) => {
+  const { db } = t.context;
+
+  const result = await db
+    .select({
+      id: sql<number>`users.id`,
+      name: sql<string>`users.name`,
+      userCity: sql<string>`users.city`,
+      cityName: sql<string>`cities.name`
+    })
+    .from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+    .leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+  Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+  t.deepEqual(result, [{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' }]);
+});
+
+test.skip('join on aliased sql from select', async (t) => {
+  const { db } = t.context;
+
+  const result = await db
+    .select({
+      userId: sql<number>`users.id`.as('userId'),
+      name: sql<string>`users.name`,
+      userCity: sql<string>`users.city`,
+      cityId: sql<number>`cities.id`.as('cityId'),
+      cityName: sql<string>`cities.name`
+    })
+    .from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+    .leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+  Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+  t.deepEqual(result, [{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' }]);
+});
+
+test.skip('join on aliased sql from with clause', async (t) => {
+  const { db } = t.context;
+
+  const users = db.$with('users').as(
+    db
+      .select({
+        id: sql<number>`id`.as('userId'),
+        name: sql<string>`name`.as('userName'),
+        city: sql<string>`city`.as('city')
+      })
+      .from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+  );
+
+  const cities = db.$with('cities').as(
+    db
+      .select({
+        id: sql<number>`id`.as('cityId'),
+        name: sql<string>`name`.as('cityName')
+      })
+      .from(sql`(select 1 as id, 'Paris' as name) as cities`)
+  );
+
+  const result = await db
+    .with(users, cities)
+    .select({
+      userId: users.id,
+      name: users.name,
+      userCity: users.city,
+      cityId: cities.id,
+      cityName: cities.name
+    })
+    .from(users)
+    .leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+  Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+  t.deepEqual(result, [{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' }]);
+});
+
+test.skip('prefixed table', async (t) => {
+  const { db } = t.context;
+
+  const pgTable = pgTableCreator((name) => `myprefix_${name}`);
+
+  const users = pgTable('test_prefixed_table_with_unique_name', {
+    id: integer('id').primaryKey(),
+    name: text('name').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(
+    sql`create table myprefix_test_prefixed_table_with_unique_name (id integer not null primary key, name text not null)`
+  );
+
+  await db.insert(users).values({ id: 1, name: 'John' });
+
+  const result = await db.select().from(users);
+
+  t.deepEqual(result, [{ id: 1, name: 'John' }]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('select from enum', async (t) => {
+  const { db } = t.context;
+
+  const muscleEnum = pgEnum('muscle', [
+    'abdominals',
+    'hamstrings',
+    'adductors',
+    'quadriceps',
+    'biceps',
+    'shoulders',
+    'chest',
+    'middle_back',
+    'calves',
+    'glutes',
+    'lower_back',
+    'lats',
+    'triceps',
+    'traps',
+    'forearms',
+    'neck',
+    'abductors'
+  ]);
+
+  const forceEnum = pgEnum('force', ['isometric', 'isotonic', 'isokinetic']);
+
+  const levelEnum = pgEnum('level', ['beginner', 'intermediate', 'advanced']);
+
+  const mechanicEnum = pgEnum('mechanic', ['compound', 'isolation']);
+
+  const equipmentEnum = pgEnum('equipment', ['barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell']);
+
+  const categoryEnum = pgEnum('category', ['upper_body', 'lower_body', 'full_body']);
+
+  const exercises = pgTable('exercises', {
+    id: serial('id').primaryKey(),
+    name: varchar('name').notNull(),
+    force: forceEnum('force'),
+    level: levelEnum('level'),
+    mechanic: mechanicEnum('mechanic'),
+    equipment: equipmentEnum('equipment'),
+    instructions: text('instructions'),
+    category: categoryEnum('category'),
+    primaryMuscles: muscleEnum('primary_muscles').array(),
+    secondaryMuscles: muscleEnum('secondary_muscles').array(),
+    createdAt: timestamp('created_at')
+      .notNull()
+      .default(sql`now()`),
+    updatedAt: timestamp('updated_at')
+      .notNull()
+      .default(sql`now()`)
+  });
+
+  await db.execute(sql`drop table if exists ${exercises}`);
+  await db.execute(sql`drop type if exists ${name(muscleEnum.enumName)}`);
+  await db.execute(sql`drop type if exists ${name(forceEnum.enumName)}`);
+  await db.execute(sql`drop type if exists ${name(levelEnum.enumName)}`);
+  await db.execute(sql`drop type if exists ${name(mechanicEnum.enumName)}`);
+  await db.execute(sql`drop type if exists ${name(equipmentEnum.enumName)}`);
+  await db.execute(sql`drop type if exists ${name(categoryEnum.enumName)}`);
+
+  await db.execute(
+    sql`create type ${name(
+      muscleEnum.enumName
+    )} as enum ('abdominals', 'hamstrings', 'adductors', 'quadriceps', 'biceps', 'shoulders', 'chest', 'middle_back', 'calves', 'glutes', 'lower_back', 'lats', 'triceps', 'traps', 'forearms', 'neck', 'abductors')`
+  );
+  await db.execute(sql`create type ${name(forceEnum.enumName)} as enum ('isometric', 'isotonic', 'isokinetic')`);
+  await db.execute(sql`create type ${name(levelEnum.enumName)} as enum ('beginner', 'intermediate', 'advanced')`);
+  await db.execute(sql`create type ${name(mechanicEnum.enumName)} as enum ('compound', 'isolation')`);
+  await db.execute(
+    sql`create type ${name(
+      equipmentEnum.enumName
+    )} as enum ('barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell')`
+  );
+  await db.execute(sql`create type ${name(categoryEnum.enumName)} as enum ('upper_body', 'lower_body', 'full_body')`);
+  await db.execute(sql`
+		create table ${exercises} (
+			id serial primary key,
+			name varchar not null,
+			force force,
+			level level,
+			mechanic mechanic,
+			equipment equipment,
+			instructions text,
+			category category,
+			primary_muscles muscle[],
+			secondary_muscles muscle[],
+			created_at timestamp not null default now(),
+			updated_at timestamp not null default now()
+		)
+	`);
+
+  await db.insert(exercises).values({
+    name: 'Bench Press',
+    force: 'isotonic',
+    level: 'beginner',
+    mechanic: 'compound',
+    equipment: 'barbell',
+    instructions:
+      'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+    category: 'upper_body',
+    primaryMuscles: ['chest', 'triceps'],
+    secondaryMuscles: ['shoulders', 'traps']
+  });
+
+  const result = await db.select().from(exercises);
+
+  t.deepEqual(result, [
+    {
+      id: 1,
+      name: 'Bench Press',
+      force: 'isotonic',
+      level: 'beginner',
+      mechanic: 'compound',
+      equipment: 'barbell',
+      instructions:
+        'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+      category: 'upper_body',
+      primaryMuscles: ['chest', 'triceps'],
+      secondaryMuscles: ['shoulders', 'traps'],
+      createdAt: result[0]!.createdAt,
+      updatedAt: result[0]!.updatedAt
+    }
+  ]);
+
+  await db.execute(sql`drop table ${exercises}`);
+  await db.execute(sql`drop type ${name(muscleEnum.enumName)}`);
+  await db.execute(sql`drop type ${name(forceEnum.enumName)}`);
+  await db.execute(sql`drop type ${name(levelEnum.enumName)}`);
+  await db.execute(sql`drop type ${name(mechanicEnum.enumName)}`);
+  await db.execute(sql`drop type ${name(equipmentEnum.enumName)}`);
+  await db.execute(sql`drop type ${name(categoryEnum.enumName)}`);
+});
+
+test('orderBy with aliased column', (t) => {
+  const { db } = t.context;
+
+  const query = db
+    .select({
+      test: sql`something`.as('test')
+    })
+    .from(users2Table)
+    .orderBy((fields) => fields.test)
+    .toSQL();
+
+  t.deepEqual(query.sql, 'select something as "test" from "users2" order by "test"');
+});
+
+test.skip('select from sql', async (t) => {
+  const { db } = t.context;
+
+  const metricEntry = pgTable('metric_entry', {
+    id: pgUuid('id').notNull(),
+    createdAt: timestamp('created_at').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${metricEntry}`);
+  await db.execute(sql`create table ${metricEntry} (id uuid not null, created_at timestamp not null)`);
+
+  const metricId = uuid();
+
+  const intervals = db.$with('intervals').as(
+    db
+      .select({
+        startTime: sql<string>`(date'2023-03-01'+ x * '1 day'::interval)`.as('start_time'),
+        endTime: sql<string>`(date'2023-03-01'+ (x+1) *'1 day'::interval)`.as('end_time')
+      })
+      .from(sql`generate_series(0, 29, 1) as t(x)`)
+  );
+
+  await t.notThrowsAsync(() =>
+    db
+      .with(intervals)
+      .select({
+        startTime: intervals.startTime,
+        endTime: intervals.endTime,
+        count: sql<number>`count(${metricEntry})`
+      })
+      .from(metricEntry)
+      .rightJoin(
+        intervals,
+        and(
+          eq(metricEntry.id, metricId),
+          gte(metricEntry.createdAt, intervals.startTime),
+          lt(metricEntry.createdAt, intervals.endTime)
+        )
+      )
+      .groupBy(intervals.startTime, intervals.endTime)
+      .orderBy(asc(intervals.startTime))
+  );
+});
+
+test.skip('timestamp timezone', async (t) => {
+  const { db } = t.context;
+
+  const usersTableWithAndWithoutTimezone = pgTable('users_test_with_and_without_timezone', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: false }).notNull().defaultNow()
+  });
+
+  await db.execute(sql`drop table if exists ${usersTableWithAndWithoutTimezone}`);
+
+  await db.execute(
+    sql`
+			create table users_test_with_and_without_timezone (
+				id serial not null primary key,
+				name text not null,
+				created_at timestamptz not null default now(),
+				updated_at timestamp not null default now()
+			)
+		`
+  );
+
+  const date = new Date(Date.parse('2020-01-01T00:00:00+04:00'));
+
+  await db.insert(usersTableWithAndWithoutTimezone).values({ name: 'With default times' });
+  await db.insert(usersTableWithAndWithoutTimezone).values({
+    name: 'Without default times',
+    createdAt: date,
+    updatedAt: date
+  });
+  const users = await db.select().from(usersTableWithAndWithoutTimezone);
+
+  // check that the timestamps are set correctly for default times
+  t.assert(Math.abs(users[0]!.updatedAt.getTime() - Date.now()) < 2000);
+  t.assert(Math.abs(users[0]!.createdAt.getTime() - Date.now()) < 2000);
+
+  // check that the timestamps are set correctly for non default times
+  t.assert(Math.abs(users[1]!.updatedAt.getTime() - date.getTime()) < 2000);
+  t.assert(Math.abs(users[1]!.createdAt.getTime() - date.getTime()) < 2000);
+});
+
+test.skip('transaction', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users_transactions', {
+    id: serial('id').primaryKey(),
+    balance: integer('balance').notNull()
+  });
+  const products = pgTable('products_transactions', {
+    id: serial('id').primaryKey(),
+    price: integer('price').notNull(),
+    stock: integer('stock').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+  await db.execute(sql`drop table if exists ${products}`);
+
+  await db.execute(sql`create table users_transactions (id serial not null primary key, balance integer not null)`);
+  await db.execute(
+    sql`create table products_transactions (id serial not null primary key, price integer not null, stock integer not null)`
+  );
+
+  const user = await db
+    .insert(users)
+    .values({ balance: 100 })
+    .returning()
+    .then((rows) => rows[0]!);
+  const product = await db
+    .insert(products)
+    .values({ price: 10, stock: 10 })
+    .returning()
+    .then((rows) => rows[0]!);
+
+  await db.transaction(async (tx) => {
+    await tx
+      .update(users)
+      .set({ balance: user.balance - product.price })
+      .where(eq(users.id, user.id));
+    await tx
+      .update(products)
+      .set({ stock: product.stock - 1 })
+      .where(eq(products.id, product.id));
+  });
+
+  const result = await db.select().from(users);
+
+  t.deepEqual(result, [{ id: 1, balance: 90 }]);
+
+  await db.execute(sql`drop table ${users}`);
+  await db.execute(sql`drop table ${products}`);
+});
+
+test.skip('transaction rollback', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users_transactions_rollback', {
+    id: serial('id').primaryKey(),
+    balance: integer('balance').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(
+    sql`create table users_transactions_rollback (id serial not null primary key, balance integer not null)`
+  );
+
+  await t.throwsAsync(
+    async () =>
+      await db.transaction(async (tx) => {
+        await tx.insert(users).values({ balance: 100 });
+        tx.rollback();
+      }),
+    new TransactionRollbackError()
+  );
+
+  const result = await db.select().from(users);
+
+  t.deepEqual(result, []);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('nested transaction', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users_nested_transactions', {
+    id: serial('id').primaryKey(),
+    balance: integer('balance').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(
+    sql`create table users_nested_transactions (id serial not null primary key, balance integer not null)`
+  );
+
+  await db.transaction(async (tx) => {
+    await tx.insert(users).values({ balance: 100 });
+
+    await tx.transaction(async (tx) => {
+      await tx.update(users).set({ balance: 200 });
+    });
+  });
+
+  const result = await db.select().from(users);
+
+  t.deepEqual(result, [{ id: 1, balance: 200 }]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('nested transaction rollback', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users_nested_transactions_rollback', {
+    id: serial('id').primaryKey(),
+    balance: integer('balance').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(
+    sql`create table users_nested_transactions_rollback (id serial not null primary key, balance integer not null)`
+  );
+
+  await db.transaction(async (tx) => {
+    await tx.insert(users).values({ balance: 100 });
+
+    await t.throwsAsync(
+      async () =>
+        await tx.transaction(async (tx) => {
+          await tx.update(users).set({ balance: 200 });
+          tx.rollback();
+        }),
+      new TransactionRollbackError()
+    );
+  });
+
+  const result = await db.select().from(users);
+
+  t.deepEqual(result, [{ id: 1, balance: 100 }]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('join subquery with join', async (t) => {
+  const { db } = t.context;
+
+  const internalStaff = pgTable('internal_staff', {
+    userId: integer('user_id').notNull()
+  });
+
+  const customUser = pgTable('custom_user', {
+    id: integer('id').notNull()
+  });
+
+  const ticket = pgTable('ticket', {
+    staffId: integer('staff_id').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${internalStaff}`);
+  await db.execute(sql`drop table if exists ${customUser}`);
+  await db.execute(sql`drop table if exists ${ticket}`);
+
+  await db.execute(sql`create table internal_staff (user_id integer not null)`);
+  await db.execute(sql`create table custom_user (id integer not null)`);
+  await db.execute(sql`create table ticket (staff_id integer not null)`);
+
+  await db.insert(internalStaff).values({ userId: 1 });
+  await db.insert(customUser).values({ id: 1 });
+  await db.insert(ticket).values({ staffId: 1 });
+
+  const subq = db
+    .select()
+    .from(internalStaff)
+    .leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+    .as('internal_staff');
+
+  const mainQuery = await db.select().from(ticket).leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+  t.deepEqual(mainQuery, [
+    {
+      ticket: { staffId: 1 },
+      internal_staff: {
+        internal_staff: { userId: 1 },
+        custom_user: { id: 1 }
+      }
+    }
+  ]);
+
+  await db.execute(sql`drop table ${internalStaff}`);
+  await db.execute(sql`drop table ${customUser}`);
+  await db.execute(sql`drop table ${ticket}`);
+});
+
+test.skip('subquery with view', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users_subquery_view', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  });
+
+  const newYorkers = pgView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+  await db.execute(sql`drop table if exists ${users}`);
+  await db.execute(sql`drop view if exists ${newYorkers}`);
+
+  await db.execute(
+    sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`
+  );
+  await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+  await db.insert(users).values([
+    { name: 'John', cityId: 1 },
+    { name: 'Jane', cityId: 2 },
+    { name: 'Jack', cityId: 1 },
+    { name: 'Jill', cityId: 2 }
+  ]);
+
+  const sq = db.$with('sq').as(db.select().from(newYorkers));
+  const result = await db.with(sq).select().from(sq);
+
+  t.deepEqual(result, [
+    { id: 1, name: 'John', cityId: 1 },
+    { id: 3, name: 'Jack', cityId: 1 }
+  ]);
+
+  await db.execute(sql`drop view ${newYorkers}`);
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('join view as subquery', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users_join_view', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  });
+
+  const newYorkers = pgView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+  await db.execute(sql`drop table if exists ${users}`);
+  await db.execute(sql`drop view if exists ${newYorkers}`);
+
+  await db.execute(
+    sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`
+  );
+  await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+  await db.insert(users).values([
+    { name: 'John', cityId: 1 },
+    { name: 'Jane', cityId: 2 },
+    { name: 'Jack', cityId: 1 },
+    { name: 'Jill', cityId: 2 }
+  ]);
+
+  const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+  const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+  t.deepEqual(result, [
+    {
+      users_join_view: { id: 1, name: 'John', cityId: 1 },
+      new_yorkers_sq: { id: 1, name: 'John', cityId: 1 }
+    },
+    {
+      users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+      new_yorkers_sq: null
+    },
+    {
+      users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+      new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 }
+    },
+    {
+      users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+      new_yorkers_sq: null
+    }
+  ]);
+
+  await db.execute(sql`drop view ${newYorkers}`);
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('table selection with single table', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users', {
+    id: serial('id').primaryKey(),
+    name: text('name').notNull(),
+    cityId: integer('city_id').notNull()
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(
+    sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`
+  );
+
+  await db.insert(users).values({ name: 'John', cityId: 1 });
+
+  const result = await db.select({ users }).from(users);
+
+  t.deepEqual(result, [{ users: { id: 1, name: 'John', cityId: 1 } }]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('set null to jsonb field', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users', {
+    id: serial('id').primaryKey(),
+    jsonb: jsonb('jsonb')
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(sql`create table ${users} (id serial not null primary key, jsonb jsonb)`);
+
+  const result = await db.insert(users).values({ jsonb: null }).returning();
+
+  t.deepEqual(result, [{ id: 1, jsonb: null }]);
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('insert undefined', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users', {
+    id: serial('id').primaryKey(),
+    name: text('name')
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(sql`create table ${users} (id serial not null primary key, name text)`);
+
+  await t.notThrowsAsync(async () => await db.insert(users).values({ name: undefined }));
+
+  await db.execute(sql`drop table ${users}`);
+});
+
+test.skip('update undefined', async (t) => {
+  const { db } = t.context;
+
+  const users = pgTable('users', {
+    id: serial('id').primaryKey(),
+    name: text('name')
+  });
+
+  await db.execute(sql`drop table if exists ${users}`);
+
+  await db.execute(sql`create table ${users} (id serial not null primary key, name text)`);
+
+  await t.throwsAsync(async () => await db.update(users).set({ name: undefined }));
+  await t.notThrowsAsync(async () => await db.update(users).set({ id: 1, name: undefined }));
+
+  await db.execute(sql`drop table ${users}`);
+});