Drizzle ORM

https://orm.drizzle.team/docs
Admin
Drizzle ORM is a headless, typesafe TypeScript ORM offering both relational and SQL-like query APIs....
Tokens:951,874
Snippets:7,232
Trust Score:8
Update:1 day ago
Show doc for...
Tokens:
Raw
### Basic file structure after setup

Source: https://orm.drizzle.team/docs/get-started/expo-new

Shows the expected file structure after installing the template and adding the db folder. Includes drizzle folder for migrations and snapshots.

```text
📦 <project root>
 ├ 📂 assets
 ├ 📂 drizzle
 ├ 📂 db
 │  └ 📜 schema.ts
 ├ 📜 .gitignore
 ├ 📜 .npmrc
 ├ 📜 app.json
 ├ 📜 App.tsx
 ├ 📜 babel.config.ts
 ├ 📜 drizzle.config.ts
 ├ 📜 package.json
 └ 📜 tsconfig.json
```

--------------------------------

### Connect to database and run first query

Source: https://orm.drizzle.team/docs/latest-releases/drizzle-orm-v0110

Quick start example showing how to connect to a PostgreSQL database and execute a select query with a fully typed result.

```typescript
import { drizzle, PgTable } from 'drizzle-orm'

export class UsersTable extends PgTable<UsersTable> {
  public id = this.serial('id').primaryKey();
  public fullName = this.text('full_name');
  public phone = this.varchar('phone', { size: 256 });

  public tableName(): string {
    return 'users';
  }
}
export type User = InferType<UsersTable>

const db = await drizzle.connect("postgres://user:password@host:port/db");
const usersTable = new UsersTable(db);

const users: User[] = await usersTable.select().execute();
```

--------------------------------

### Example output of similar guides

Source: https://orm.drizzle.team/docs/cockroach/guides/vector-similarity-search

Example result array returned by findSimilarGuides, showing the top 4 similar guides with their similarity scores.

```json
[
  {
    "name": "Drizzle with Turso",
    "url": "/docs/tutorials/drizzle-with-turso",
    "similarity": 0.8642314333984994
  },
  {
    "name": "Drizzle with Supabase Database",
    "url": "/docs/tutorials/drizzle-with-supabase",
    "similarity": 0.8593631126014918
  },
  {
    "name": "Drizzle with Neon Postgres",
    "url": "/docs/tutorials/drizzle-with-neon",
    "similarity": 0.8541051184461372
  },
  {
    "name": "Drizzle with Vercel Edge Functions",
    "url": "/docs/tutorials/drizzle-with-vercel-edge-functions",
    "similarity": 0.8481551084241092
  }
]
```

--------------------------------

### Example .env with file: prefix

Source: https://orm.drizzle.team/docs/get-started/sqlite-new

Shows the required format for a local SQLite file: use 'file:' before the filename as required by LibSQL.

```bash
DB_FILE_NAME=file:local.db
```

--------------------------------

### Install GraphQL Yoga dependencies with bun

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, graphql-yoga, and graphql using bun for the GraphQL Yoga setup.

```bash
bun add drizzle-graphql graphql-yoga graphql
```

--------------------------------

### Install GraphQL Yoga dependencies with pnpm

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, graphql-yoga, and graphql using pnpm for the GraphQL Yoga setup.

```bash
pnpm add drizzle-graphql graphql-yoga graphql
```

--------------------------------

### Example database URL for the created container

Source: https://orm.drizzle.team/docs/cockroach/guides/postgresql-local-setup

Example URL using the container's credentials and host.

```text
postgres://postgres:mypassword@localhost:5432/postgres
```

--------------------------------

### Install GraphQL Yoga dependencies with yarn

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, graphql-yoga, and graphql using yarn for the GraphQL Yoga setup.

```bash
yarn add drizzle-graphql graphql-yoga graphql
```

--------------------------------

### Install @libsql/client with bun

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-turso

Install the @libsql/client package using bun.

```bash
bun add @libsql/client
```

--------------------------------

### Install GraphQL Yoga dependencies with npm

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, graphql-yoga, and graphql using npm for the GraphQL Yoga setup.

```bash
npm i drizzle-graphql graphql-yoga graphql
```

--------------------------------

### Install Apollo Server dependencies with bun

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, @apollo/server, and graphql using bun for the Apollo Server setup.

```bash
bun add drizzle-graphql @apollo/server graphql
```

--------------------------------

### Extended example: generated migration folder structure

Source: https://orm.drizzle.team/docs/drizzle-kit-generate

Shows the resulting folder structure after running the extended example command.

```text
📦 <project root>
 ├ …
 ├ 📂 migrations
 │ ├ 📂 20242409125510_init
 │ └ 📂 20242409125510_seed-users
 └ …
```

--------------------------------

### Example 2: Multiple schema files in different directories

Source: https://orm.drizzle.team/docs/drizzle-kit-export

Project structure with schema files in user and posts directories.

```text
📦 <project root>
 ├ ...
 ├ 📂 drizzle
 ├ 📂 src
 │ ├ 📂 user
 │ │ ├ 📜 handler.ts 
 │ │ └ 📜 schema.ts 
 │ ├ 📂 posts
 │ │ ├ 📜 handler.ts 
 │ │ └ 📜 schema.ts 
 │ └ 📜 index.ts
 ├ 📜 drizzle.config.ts
 └ 📜 package.json
```

--------------------------------

### Install Apollo Server dependencies with pnpm

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, @apollo/server, and graphql using pnpm for the Apollo Server setup.

```bash
pnpm add drizzle-graphql @apollo/server graphql
```

--------------------------------

### Install Apollo Server dependencies with yarn

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, @apollo/server, and graphql using yarn for the Apollo Server setup.

```bash
yarn add drizzle-graphql @apollo/server graphql
```

--------------------------------

### Initialize Gel project with bun

Source: https://orm.drizzle.team/docs/get-started/gel-new

Command to initialize a new Gel project using bun.

```bash
bunx gel project init
```

--------------------------------

### Install @libsql/client

Source: https://orm.drizzle.team/docs/mysql/tutorials/drizzle-with-turso

Install the @libsql/client package, the libSQL client library used with Turso.

```bash
npm i @libsql/client
```

```bash
yarn add @libsql/client
```

```bash
pnpm add @libsql/client
```

```bash
bun add @libsql/client
```

--------------------------------

### Install Apollo Server dependencies with npm

Source: https://orm.drizzle.team/docs/cockroach/graphql

Installs drizzle-graphql, @apollo/server, and graphql using npm for the Apollo Server setup.

```bash
npm i drizzle-graphql @apollo/server graphql
```

--------------------------------

### drizzle-kit push with all configuration via CLI (npm, yarn, pnpm, bun)

Source: https://orm.drizzle.team/docs/drizzle-kit-push

Shows how to provide all configuration options through the CLI instead of a config file. Includes examples for a standard PostgreSQL connection, a pglite driver, and using --tablesFilter and --extensionsFilters flags.

```bash
npx drizzle-kit push dialect=postgresql schema=src/schema.ts url=postgresql://user:password@host:port/dbname
npx drizzle-kit push dialect=postgresql schema=src/schema.ts driver=pglite url=database/
npx drizzle-kit push dialect=postgresql schema=src/schema.ts --tablesFilter=‘user*’ --extensionsFilters=postgis url=postgresql://user:password@host:port/dbname
```

```bash
yarn drizzle-kit push dialect=postgresql schema=src/schema.ts url=postgresql://user:password@host:port/dbname
yarn drizzle-kit push dialect=postgresql schema=src/schema.ts driver=pglite url=database/
yarn drizzle-kit push dialect=postgresql schema=src/schema.ts --tablesFilter=‘user*’ --extensionsFilters=postgis url=postgresql://user:password@host:port/dbname
```

```bash
pnpm drizzle-kit push dialect=postgresql schema=src/schema.ts url=postgresql://user:password@host:port/dbname
pnpm drizzle-kit push dialect=postgresql schema=src/schema.ts driver=pglite url=database/
pnpm drizzle-kit push dialect=postgresql schema=src/schema.ts --tablesFilter=‘user*’ --extensionsFilters=postgis url=postgresql://user:password@host:port/dbname
```

```bash
bunx drizzle-kit push dialect=postgresql schema=src/schema.ts url=postgresql://user:password@host:port/dbname
bunx drizzle-kit push dialect=postgresql schema=src/schema.ts driver=pglite url=database/
bunx drizzle-kit push dialect=postgresql schema=src/schema.ts --tablesFilter=‘user*’ --extensionsFilters=postgis url=postgresql://user:password@host:port/dbname
```

--------------------------------

### Get Typed Columns with getColumns

Source: https://orm.drizzle.team/docs/cockroach/goodies

Use getColumns to get a typed column map, useful for excluding fields from a selection. The example shows destructuring to omit password and role.

```typescript
import { getColumns } from 'drizzle-orm';
import { users } from './schema';

const { password, role, ...rest } = getColumns(users);

await db.select({ ...rest }).from(users);
```

--------------------------------

### package.json - start script

Source: https://orm.drizzle.team/docs/cockroach/tutorials/bun-railway-pg

Defines the start script to run the application with Bun.

```json
{
  "scripts": {
    "start": "bun src/index.ts"
  }
}
```

--------------------------------

### intPrimaryKey generator example

Source: https://orm.drizzle.team/docs/cockroach/seed-functions

Generates sequential integers starting from 1. No parameters are required.

```typescript
import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      id: funcs.intPrimaryKey(),
    },
  },
}));
```

--------------------------------

### Set up .env with DATABASE_URL

Source: https://orm.drizzle.team/docs/get-started/appwrite-postgres-new

Create a .env file with the Appwrite Postgres connection string, including sslmode=require.

```bash
DATABASE_URL=postgresql://admin:<password>@db-<hash>.<region>.appwrite.center:5432/<database>?sslmode=require
```

--------------------------------

### Setup: index.ts with relations (alternative)

Source: https://orm.drizzle.team/docs/mysql/rqb

Alternative initialization of the database with relations and a query example.

```typescript
import { relations } from './relations';
import { drizzle } from 'drizzle-orm/mysql2';

const db = drizzle(process.env.DATABASE_URL, { relations });

await db.query.users.findMany(...);
```

--------------------------------

### sql.empty() - start with blank SQL and append

Source: https://orm.drizzle.team/docs/cockroach/sql

Initializes an empty SQL object and appends chunks to build a query incrementally. The example produces the same parameterized query as the sql.append() example, with placeholders $1 to $5.

```javascript
const finalSql = sql.empty();

// some logic

finalSql.append(sql`select * from users`);

// some logic

finalSql.append(sql` where `);

// some logic

for (let i = 0; i < 5; i++) {
	finalSql.append(sql`id = ${i}`);

	if (i === 4) continue;
	finalSql.append(sql` or `);
}
```

```sql
select * from users where id = $1 or id = $2 or id = $3 or id = $4 or id = $5; --> [0, 1, 2, 3, 4]
```

--------------------------------

### Example 4: SQL schema files spread across project

Source: https://orm.drizzle.team/docs/drizzle-kit-export

Project structure with .sql.ts files in src root.

```text
📦 <project root>
 ├ ...
 ├ 📂 drizzle
 ├ 📂 src
 │ ├ 📜 userById.ts 
 │ ├ 📜 userByEmail.ts 
 │ ├ 📜 listUsers.ts 
 │ ├ 📜 user.sql.ts 
 │ ├ 📜 postById.ts 
 │ ├ 📜 listPosts.ts 
 │ └ 📜 post.sql.ts 
 │ 📜 index.ts
 ├ 📜 drizzle.config.ts
 └ 📜 package.json
```

--------------------------------

### Install @libsql/client with npm

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-turso

Install the @libsql/client package using npm.

```bash
npm i @libsql/client
```

--------------------------------

### PGlite driver usage example

Source: https://orm.drizzle.team/docs/latest-releases/drizzle-orm-v0306

Shows how to initialize an in-memory PGlite database and use it with Drizzle ORM. Requires installing @electric-sql/pglite and drizzle-orm/pglite. The example creates a PGlite client, passes it to drizzle, and performs a select query.

```typescript
import { PGlite } from '@electric-sql/pglite';
import { drizzle } from 'drizzle-orm/pglite';
import { users } from './schema';

// In-memory Postgres
const client = new PGlite();
const db = drizzle(client);

await db.select().from(users);
```

--------------------------------

### Use .as() for column aliases

Source: https://orm.drizzle.team/docs/singlestore/select

Starting from `v1.0.0-beta.1`, you can use `.as()` to alias columns in a select. This example aliases `users.name` as `lower`.

```typescript
const result = await db.select({
  id: users.id,
  lowerName: users.name.as("lower"),
}).from(users);
```

--------------------------------

### Example output of docker images

Source: https://orm.drizzle.team/docs/cockroach/guides/postgresql-local-setup

Example output showing the postgres image details.

```text
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
postgres     latest    75282fa229a1   6 weeks ago     453MB
```

--------------------------------

### NOT condition in where clause

Source: https://orm.drizzle.team/docs/relations-v1-v2

Example of using the `NOT` operator in the `where` object. The query filters users where `id` is NOT greater than 10 AND `name` starts with 'John'.

```typescript
const response = await db.query.users.findMany({
  where: {
    NOT: {
      id: {
        gt: 10,
      },
    },
    name: {
      like: "John%",
    },
  },
});
```

```sql
select
  "d0"."id" as "id",
  "d0"."name" as "name",
  "d0"."age" as "age"
from
  "users" as "d0"
where
  (
    (not ("d0"."id" > 10))
    and ("d0"."name" like 'John%')
  )
```

--------------------------------

### Set up DATABASE_URL environment variable

Source: https://orm.drizzle.team/docs/get-started/appwrite-mysql-new

Create a .env file with the Appwrite MySQL connection string. The username is admin.<hash> and the database name is always 'default'.

```bash
DATABASE_URL=mysql://admin.<hash>:<password>@db-<hash>.<region>.appwrite.center:3306/default?ssl=true
```

--------------------------------

### OR condition in where clause

Source: https://orm.drizzle.team/docs/relations-v1-v2

Example of using the `OR` operator in the `where` object. The query filters users where `id` is greater than 10 OR `name` starts with 'John'.

```typescript
const response = await db.query.users.findMany({
  where: {
    OR: [
      {
        id: {
          gt: 10,
        },
      },
      {
        name: {
          like: "John%",
        },
      },
    ],
  },
});
```

```sql
select
  "d0"."id" as "id",
  "d0"."name" as "name",
  "d0"."age" as "age"
from
  "users" as "d0"
where
  (
    ("d0"."id" > 10)
    or ("d0"."name" like 'John%')
  )
```

--------------------------------

### Install @libsql/client with yarn

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-turso

Install the @libsql/client package using yarn.

```bash
yarn add @libsql/client
```

--------------------------------

### v1 query example for many-to-many

Source: https://orm.drizzle.team/docs/mysql/relations-v1-v2

Shows the v1 query that manually traverses the junction table `usersToGroups` to get groups for a user.

```typescript
// Query example
const response = await db.query.users.findMany({
  with: {
    usersToGroups: {
      columns: {},
      with: {
        group: true,
      },
    },
  },
});
```

--------------------------------

### Install @planetscale/database driver with bun

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-vercel-edge-functions

Install the @planetscale/database driver using bun.

```bash
bun add @planetscale/database
```

--------------------------------

### Setup: schema.ts with table definitions

Source: https://orm.drizzle.team/docs/sqlite/rqb

Defines the posts and users tables using drizzle-orm/sqlite-core. These tables are used in the relational query example.

```typescript
import * as t from "drizzle-orm/sqlite-core";

export const posts = t.sqliteTable("posts", {
id: t.integer().primaryKey({ autoIncrement: true }),
content: t.text().notNull(),
authorId: t.integer("author_id").notNull(),
});

export const users = t.sqliteTable("users", {
id: t.integer().primaryKey({ autoIncrement: true }),
name: t.text().notNull(),
});
```

--------------------------------

### Example MySQL database URL

Source: https://orm.drizzle.team/docs/cockroach/guides/mysql-local-setup

Example URL for the created container, using root user and password mypassword.

```text
mysql://root:mypassword@localhost:3306/mysql
```

--------------------------------

### Create .env with DB_FILE_NAME placeholder

Source: https://orm.drizzle.team/docs/get-started/bun-sqlite-new

Create a .env file in the project root and add the database connection variable placeholder.

```text
DB_FILE_NAME=
```

--------------------------------

### Set up DATABASE_URL in .env

Source: https://orm.drizzle.team/docs/get-started/planetscale-postgres-new

Create a .env file with the DATABASE_URL connection string. Credentials can be obtained from the PlanetScale dashboard.

```plaintext
DATABASE_URL=postgresql://{username}:{password}@{host}:{port}/postgres?sslmode=verify-full
```

--------------------------------

### Apollo Server setup (server.ts)

Source: https://orm.drizzle.team/docs/cockroach/graphql

Creates a GraphQL server using Apollo Server and drizzle-graphql. Builds the schema from a Drizzle instance and starts the server, logging the URL.

```typescript
import { buildSchema } from 'drizzle-graphql';
import { drizzle } from 'drizzle-orm/...';
import client from './db';
import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

import * as dbSchema from './schema';

const db = drizzle({ client, schema: dbSchema });

const { schema } = buildSchema(db);

const server = new ApolloServer({ schema });
const { url } = await startStandaloneServer(server);

console.log(`🚀 Server ready at ${url}`);
```

--------------------------------

### Initialize a new Supabase project

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-supabase-edge-functions

Initializes a new Supabase project in the current folder, creating a supabase folder with a config.toml file.

```bash
supabase init
```

--------------------------------

### Start drizzle-kit studio

Source: https://orm.drizzle.team/docs/cockroach/drizzle-kit-studio

Command to start the Drizzle Studio server on the default host and port (127.0.0.1:4983).

```bash
npx drizzle-kit studio
```

--------------------------------

### sql.empty() - Build dynamic SQL query from blank

Source: https://orm.drizzle.team/docs/mssql/sql

Starts with an empty SQL object and appends chunks to construct the same query as the append example. Demonstrates incremental construction with parameterization.

```typescript
const finalSql = sql.empty();

// some logic

finalSql.append(sql`select * from users`);

// some logic

finalSql.append(sql` where `);

// some logic

for (let i = 0; i < 5; i++) {
	finalSql.append(sql`id = ${i}`);

	if (i === 4) continue;
	finalSql.append(sql` or `);
}
```

```sql
select * from users where id = @par0 or id = @par1 or id = @par2 or id = @par3 or id = @par4; --> [0, 1, 2, 3, 4]
```

--------------------------------

### Install @libsql/client with pnpm

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-turso

Install the @libsql/client package using pnpm.

```bash
pnpm add @libsql/client
```

--------------------------------

### GraphQL Yoga setup (server.ts)

Source: https://orm.drizzle.team/docs/cockroach/graphql

Creates a GraphQL server using GraphQL Yoga and drizzle-graphql. Builds the schema from a Drizzle instance and starts an HTTP server on port 4000.

```typescript
import { buildSchema } from 'drizzle-graphql';
import { drizzle } from 'drizzle-orm/...';
import { createYoga } from 'graphql-yoga';
import { createServer } from 'node:http';

import * as dbSchema from './schema';

const db = drizzle({ schema: dbSchema });

const { schema } = buildSchema(db);

const yoga = createYoga({ schema });
const server = createServer(yoga);

server.listen(4000, () => {
  console.info('Server is running on http://localhost:4000/graphql');
});
```

--------------------------------

### Identity Columns: generatedAlwaysAsIdentity()

Source: https://orm.drizzle.team/docs/column-types

Defines a PostgreSQL identity column using `generatedAlwaysAsIdentity()`. The example creates an `ingredients` table with an auto-incrementing `id` starting at 1000, along with `name` and `description` text columns.

```typescript
import { pgTable, integer, text } from 'drizzle-orm/pg-core' 

export const ingredients = pgTable('ingredients', {
	id: integer().primaryKey().generatedAlwaysAsIdentity({ startWith: 1000 }),
	name: text().notNull(),
	description: text(),
});
```

--------------------------------

### Start local development server

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-vercel-edge-functions

Runs the Next.js development server.

```bash
npx next dev
```

--------------------------------

### Configure tablesFilter in drizzle-kit config

Source: https://orm.drizzle.team/docs/cockroach/drizzle-config-file

Use `tablesFilter` in `drizzle.config.ts` to specify a glob-based list of table names that `drizzle-kit push` and `pull` will manage. The example filters tables to `users`, `posts`, and any table starting with `project1_`.

```typescript
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  dialect: "cockroach",
  tablesFilter: ["users", "posts", "project1_*"],
});
```

--------------------------------

### Install express (bun)

Source: https://orm.drizzle.team/docs/cockroach/tutorials/drizzle-with-nile

Install the express package using bun.

```bash
bun add express
```

--------------------------------

### Run drizzle-kit push with CLI configuration options (npm)

Source: https://orm.drizzle.team/docs/cockroach/drizzle-kit-push

Examples of providing configuration options directly via CLI, including dialect, schema, url, driver, and tablesFilter.

```bash
npx drizzle-kit push dialect=cockroach schema=src/schema.ts url=postgresql://user:password@host:port/dbname
npx drizzle-kit push dialect=cockroach schema=src/schema.ts driver=pglite url=database/
npx drizzle-kit push dialect=cockroach schema=src/schema.ts --tablesFilter=‘user*’ url=postgresql://user:password@host:port/dbname
```

--------------------------------

### Identity Columns with generatedAlwaysAsIdentity

Source: https://orm.drizzle.team/docs/cockroach/column-types

Defines an identity column using generatedAlwaysAsIdentity with a startWith sequence option. Requires drizzle-orm@0.32.0+ and drizzle-kit@0.23.0+. The example creates an ingredients table with an auto-generated id starting at 1000.

```typescript
import { cockroachTable, int4, text } from 'drizzle-orm/cockroach-core' 

export const ingredients = cockroachTable("ingredients", {
  id: int4().primaryKey().generatedAlwaysAsIdentity({ startWith: 1000 }),
  name: text().notNull(),
  description: text(),
});
```

--------------------------------

### Run drizzle-kit push with CLI configuration options (bun)

Source: https://orm.drizzle.team/docs/cockroach/drizzle-kit-push

bun variant of the CLI configuration examples.

```bash
bunx drizzle-kit push dialect=cockroach schema=src/schema.ts url=postgresql://user:password@host:port/dbname
bunx drizzle-kit push dialect=cockroach schema=src/schema.ts driver=pglite url=database/
bunx drizzle-kit push dialect=cockroach schema=src/schema.ts --tablesFilter=‘user*’ url=postgresql://user:password@host:port/dbname
```

--------------------------------

### Standalone query builder with QueryBuilder

Source: https://orm.drizzle.team/docs/goodies

Use the PostgreSQL query builder without creating a database instance. The example creates a `QueryBuilder`, builds a select query with a where clause, and calls `.toSQL()` to get the SQL and parameters.

```typescript
import { QueryBuilder } from 'drizzle-orm/pg-core';

const qb = new QueryBuilder();
const query = qb.select().from(users).where(eq(users.name, 'Dan'));
const { sql, params } = query.toSQL();
```

--------------------------------

### Set up POSTGRES_URL environment variable

Source: https://orm.drizzle.team/docs/get-started/vercel-new

Create a .env file and add the POSTGRES_URL variable. The variable must be named POSTGRES_URL for Vercel Postgres.

```bash
POSTGRES_URL=
```

--------------------------------

### Configure extensionsFilters in drizzle.config.ts

Source: https://orm.drizzle.team/docs/drizzle-config-file

Use extensionsFilters to declare installed extensions whose tables should be ignored by drizzle-kit push and pull. The example ignores tables created by the 'postgis' extension, which otherwise would appear in the public schema.

```typescript
export default defineConfig({
  dialect: "postgresql",
  extensionsFilters: ["postgis"],
});
```
Tokens:
Raw