PostgreSQL Drivers

Complete guide to PostgreSQL database drivers in Drizzle ORM

PostgreSQL Drivers

Drizzle ORM supports multiple PostgreSQL drivers, each optimized for different deployment environments and use cases.

node-postgres (pg)

The traditional PostgreSQL driver for Node.js with robust connection pooling.

Installation

npm install drizzle-orm pg
npm install -D @types/pg

Basic Usage

Client Instance

import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';

const pool = new Pool({
  host: 'localhost',
  port: 5432,
  user: 'postgres',
  password: 'password',
  database: 'mydb',
});

const db = drizzle(pool);

Connection Pool Configuration

import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';

const pool = new Pool({
  host: 'localhost',
  port: 5432,
  user: 'postgres',
  password: 'password',
  database: 'mydb',
  max: 20, // Maximum pool size
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

const db = drizzle(pool);

Accessing the Client

const db = drizzle(pool);

// Access underlying pg client
db.$client.query('SELECT NOW()');

---

postgres.js

A modern, fast PostgreSQL driver with excellent TypeScript support.

Installation

npm install drizzle-orm postgres

Basic Usage

Client Instance

import { drizzle } from 'drizzle-orm/postgres-js';
import postgres from 'postgres';

const client = postgres({
  host: 'localhost',
  port: 5432,
  database: 'mydb',
  username: 'postgres',
  password: 'password',
});

const db = drizzle(client);

Advanced Options

import postgres from 'postgres';
import { drizzle } from 'drizzle-orm/postgres-js';

const client = postgres({
  host: 'localhost',
  port: 5432,
  database: 'mydb',
  username: 'postgres',
  password: 'password',
  max: 10,
  idle_timeout: 20,
  connect_timeout: 10,
  prepare: true, // Use prepared statements
});

const db = drizzle(client);

postgres.js automatically handles date parsing. Drizzle overrides default parsers to return raw values for consistent date handling.

---

Neon Serverless

WebSocket-based PostgreSQL driver optimized for Neon’s serverless databases.

Installation

npm install drizzle-orm @neondatabase/serverless

Basic Usage

Pool

import { drizzle } from 'drizzle-orm/neon-serverless';
import { Pool } from '@neondatabase/serverless';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

With WebSocket Polyfill

Required for environments without native WebSocket support:

import { drizzle } from 'drizzle-orm/neon-serverless';
import { Pool, neonConfig } from '@neondatabase/serverless';
import ws from 'ws';

// Option 1: Set globally
neonConfig.webSocketConstructor = ws;
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

// Option 2: Pass in config
const db = drizzle({
  connection: process.env.DATABASE_URL,
  ws,
});

---

Neon HTTP

HTTP-based PostgreSQL driver for edge environments and serverless functions.

Installation

npm install drizzle-orm @neondatabase/serverless

Basic Usage

Neon Function

import { drizzle } from 'drizzle-orm/neon-http';
import { neon } from '@neondatabase/serverless';

const sql = neon(process.env.DATABASE_URL);
const db = drizzle(sql);

Advanced Options

import { drizzle } from 'drizzle-orm/neon-http';
import { neon } from '@neondatabase/serverless';

const sql = neon(process.env.DATABASE_URL, {
  fullResults: true,
  arrayMode: false,
  fetchOptions: {
    priority: 'high',
  },
});

const db = drizzle(sql);

Row-Level Security with Auth Token

import { drizzle } from 'drizzle-orm/neon-http';
import { neon } from '@neondatabase/serverless';
import { users } from './schema';

const sql = neon(process.env.DATABASE_URL);
const db = drizzle(sql);

// Use auth token for RLS
const authToken = 'user-jwt-token';
const results = await db
  .$withAuth(authToken)
  .select()
  .from(users);

Batch Queries

import { drizzle } from 'drizzle-orm/neon-http';
import { neon } from '@neondatabase/serverless';
import { users, posts } from './schema';

const sql = neon(process.env.DATABASE_URL);
const db = drizzle(sql);

const batchResults = await db.batch([
  db.select().from(users),
  db.select().from(posts),
]);

Neon HTTP is designed for edge environments. For long-running Node.js servers, use Neon Serverless or node-postgres instead.

---

Vercel Postgres

Optimized PostgreSQL driver for Vercel deployments.

Installation

npm install drizzle-orm @vercel/postgres

Basic Usage

Default Client

import { drizzle } from 'drizzle-orm/vercel-postgres';
import { sql } from '@vercel/postgres';
import * as schema from './schema';

// Uses default @vercel/postgres client
const db = drizzle({ schema });

// Or explicitly pass the client
const db = drizzle(sql, { schema });

Environment Variables

Vercel automatically provides these environment variables:

POSTGRES_URL="..."
POSTGRES_PRISMA_URL="..."
POSTGRES_URL_NON_POOLING="..."
POSTGRES_USER="..."
POSTGRES_HOST="..."
POSTGRES_PASSWORD="..."
POSTGRES_DATABASE="..."

Vercel Edge Functions

import { drizzle } from 'drizzle-orm/vercel-postgres';
import * as schema from './schema';

const db = drizzle({ schema });

export const runtime = 'edge';

export async function GET() {
  const users = await db.select().from(schema.users);
  return Response.json(users);
}

---

Choosing a Driver

Node.js Servers

Recommended: node-postgres or postgres.js

• Connection pooling for optimal performance
• Battle-tested in production environments
• Full PostgreSQL feature support

import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

Serverless

Recommended: Neon Serverless

• WebSocket-based connections
• Optimized for serverless cold starts
• Compatible with Neon, AWS Lambda, etc.

import { drizzle } from 'drizzle-orm/neon-serverless';
import { Pool } from '@neondatabase/serverless';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

Edge Runtime

Recommended: Neon HTTP or Vercel Postgres

• HTTP-based, no persistent connections
• Works in Cloudflare Workers, Vercel Edge, etc.
• Minimal cold start overhead

import { drizzle } from 'drizzle-orm/neon-http';
import { neon } from '@neondatabase/serverless';

const sql = neon(process.env.DATABASE_URL);
const db = drizzle(sql);

Mock Database for Testing

All drivers support creating mock instances for testing:

import { drizzle } from 'drizzle-orm/node-postgres';
import * as schema from './schema';

const mockDb = drizzle.mock({ schema });

// Use in tests without a real database connection

Mock databases are useful for unit testing query builders but don’t execute actual SQL.