Prompt file imported from alexandereiseghohi/comicr (.github/prompts/postgresql-optimization.prompt.md). Fill in {{selection}} before use. Copyright stays with the author.

PostgreSQL Development Assistant

Name: postgresql-optimization
Author: alexandereiseghohi

Expert PostgreSQL guidance for {{selection}} (or entire project if no selection). Focus on PostgreSQL-specific features, optimization patterns, and advanced capabilities.

� PostgreSQL-Specific Features

JSONB Operations

-- Advanced JSONB queries
CREATE TABLE events (
    id SERIAL PRIMARY KEY,
    data JSONB NOT NULL,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- GIN index for JSONB performance
CREATE INDEX idx_events_data_gin ON events USING gin(data);

-- JSONB containment and path queries
SELECT * FROM events
WHERE data @> '{"type": "login"}'
  AND data #>> '{user,role}' = 'admin';

-- JSONB aggregation
SELECT jsonb_agg(data) FROM events WHERE data ? 'user_id';

Array Operations

-- PostgreSQL arrays
CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    tags TEXT[],
    categories INTEGER[]
);

-- Array queries and operations
SELECT * FROM posts WHERE 'postgresql' = ANY(tags);
SELECT * FROM posts WHERE tags && ARRAY['database', 'sql'];
SELECT * FROM posts WHERE array_length(tags, 1) > 3;

-- Array aggregation
SELECT array_agg(DISTINCT category) FROM posts, unnest(categories) as category;

Window Functions & Analytics

-- Advanced window functions
SELECT
    product_id,
    sale_date,
    amount,
    -- Running totals
    SUM(amount) OVER (PARTITION BY product_id ORDER BY sale_date) as running_total,
    -- Moving averages
    AVG(amount) OVER (PARTITION BY product_id ORDER BY sale_date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) as moving_avg,
    -- Rankings
    DENSE_RANK() OVER (PARTITION BY EXTRACT(month FROM sale_date) ORDER BY amount DESC) as monthly_rank,
    -- Lag/Lead for comparisons
    LAG(amount, 1) OVER (PARTITION BY product_id ORDER BY sale_date) as prev_amount
FROM sales;

Full-Text Search

-- PostgreSQL full-text search
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    title TEXT,
    content TEXT,
    search_vector tsvector
);

-- Update search vector
UPDATE documents
SET search_vector = to_tsvector('english', title || ' ' || content);

-- GIN index for search performance
CREATE INDEX idx_documents_search ON documents USING gin(search_vector);

-- Search queries
SELECT * FROM documents
WHERE search_vector @@ plainto_tsquery('english', 'postgresql database');

-- Ranking results
SELECT *, ts_rank(search_vector, plainto_tsquery('postgresql')) as rank
FROM documents
WHERE search_vector @@ plainto_tsquery('postgresql')
ORDER BY rank DESC;

� PostgreSQL Performance Tuning

Query Optimization

-- EXPLAIN ANALYZE for performance analysis
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT u.name, COUNT(o.id) as order_count
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE u.created_at > '2024-01-01'::date
GROUP BY u.id, u.name;

-- Identify slow queries from pg_stat_statements
SELECT query, calls, total_time, mean_time, rows,
       100.0 * shared_blks_hit / nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent
FROM pg_stat_statements
ORDER BY total_time DESC
LIMIT 10;

Index Strategies

-- Composite indexes for multi-column queries
CREATE INDEX idx_orders_user_date ON orders(user_id, order_date);

-- Partial indexes for filtered queries
CREATE INDEX idx_active_users ON users(created_at) WHERE status = 'active';

-- Expression indexes for computed values
CREATE INDEX idx_users_lower_email ON users(lower(email));

-- Covering indexes to avoid table lookups
CREATE INDEX idx_orders_covering ON orders(user_id, status) INCLUDE (total, created_at);

Connection & Memory Management

-- Check connection usage
SELECT count(*) as connections, state
FROM pg_stat_activity
GROUP BY state;

-- Monitor memory usage
SELECT name, setting, unit
FROM pg_settings
WHERE name IN ('shared_buffers', 'work_mem', 'maintenance_work_mem');

�️ PostgreSQL Advanced Data Types

Custom Types & Domains

-- Create custom types
CREATE TYPE address_type AS (
    street TEXT,
    city TEXT,
    postal_code TEXT,
    country TEXT
);

CREATE TYPE order_status AS ENUM ('pending', 'processing', 'shipped', 'delivered', 'cancelled');

-- Use domains for data validation
CREATE DOMAIN email_address AS TEXT
CHECK (VALUE ~* '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$');

-- Table using custom types
CREATE TABLE customers (
    id SERIAL PRIMARY KEY,
    email email_address NOT NULL,
    address address_type,
    status order_status DEFAULT 'pending'
);

Range Types

-- PostgreSQL range types
CREATE TABLE reservations (
    id SERIAL PRIMARY KEY,
    room_id INTEGER,
    reservation_period tstzrange,
    price_range numrange
);

-- Range queries
SELECT * FROM reservations
WHERE reservation_period && tstzrange('2024-07-20', '2024-07-25');

-- Exclude overlapping ranges
ALTER TABLE reservations
ADD CONSTRAINT no_overlap
EXCLUDE USING gist (room_id WITH =, reservation_period WITH &&);

Geometric Types

-- PostgreSQL geometric types
CREATE TABLE locations (
    id SERIAL PRIMARY KEY,
    name TEXT,
    coordinates POINT,
    coverage CIRCLE,
    service_area POLYGON
);

-- Geometric queries
SELECT name FROM locations
WHERE coordinates <-> point(40.7128, -74.0060) < 10; -- Within 10 units

-- GiST index for geometric data
CREATE INDEX idx_locations_coords ON locations USING gist(coordinates);

📊 PostgreSQL Extensions & Tools

Useful Extensions

-- Enable commonly used extensions
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";    -- UUID generation
CREATE EXTENSION IF NOT EXISTS "pgcrypto";     -- Cryptographic functions
CREATE EXTENSION IF NOT EXISTS "unaccent";     -- Remove accents from text
CREATE EXTENSION IF NOT EXISTS "pg_trgm";      -- Trigram matching
CREATE EXTENSION IF NOT EXISTS "btree_gin";    -- GIN indexes for btree types

-- Using extensions
SELECT uuid_generate_v4();                     -- Generate UUIDs
SELECT crypt('password', gen_salt('bf'));      -- Hash passwords
SELECT similarity('postgresql', 'postgersql'); -- Fuzzy matching

Monitoring & Maintenance

-- Database size and growth
SELECT pg_size_pretty(pg_database_size(current_database())) as db_size;

-- Table and index sizes
SELECT schemaname, tablename,
       pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size
FROM pg_tables
ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC;

-- Index usage statistics
SELECT schemaname, tablename, indexname, idx_scan, idx_tup_read, idx_tup_fetch
FROM pg_stat_user_indexes
WHERE idx_scan = 0;  -- Unused indexes

PostgreSQL-Specific Optimization Tips

Use EXPLAIN (ANALYZE, BUFFERS) for detailed query analysis
Configure postgresql.conf for your workload (OLTP vs OLAP)
Use connection pooling (pgbouncer) for high-concurrency applications
Regular VACUUM and ANALYZE for optimal performance
Partition large tables using PostgreSQL 10+ declarative partitioning
Use pg_stat_statements for query performance monitoring

📊 Monitoring and Maintenance

Query Performance Monitoring

-- Identify slow queries
SELECT query, calls, total_time, mean_time, rows
FROM pg_stat_statements
ORDER BY total_time DESC
LIMIT 10;

-- Check index usage
SELECT schemaname, tablename, indexname, idx_scan, idx_tup_read, idx_tup_fetch
FROM pg_stat_user_indexes
WHERE idx_scan = 0;

Database Maintenance

VACUUM and ANALYZE: Regular maintenance for performance
Index Maintenance: Monitor and rebuild fragmented indexes
Statistics Updates: Keep query planner statistics current
Log Analysis: Regular review of PostgreSQL logs

🛠️ Common Query Patterns

Pagination

-- ❌ BAD: OFFSET for large datasets
SELECT * FROM products ORDER BY id OFFSET 10000 LIMIT 20;

-- ✅ GOOD: Cursor-based pagination
SELECT * FROM products
WHERE id > $last_id
ORDER BY id
LIMIT 20;

Aggregation

-- ❌ BAD: Inefficient grouping
SELECT user_id, COUNT(*)
FROM orders
WHERE order_date >= '2024-01-01'
GROUP BY user_id;

-- ✅ GOOD: Optimized with partial index
CREATE INDEX idx_orders_recent ON orders(user_id)
WHERE order_date >= '2024-01-01';

SELECT user_id, COUNT(*)
FROM orders
WHERE order_date >= '2024-01-01'
GROUP BY user_id;

JSON Queries

-- ❌ BAD: Inefficient JSON querying
SELECT * FROM users WHERE data::text LIKE '%admin%';

-- ✅ GOOD: JSONB operators and GIN index
CREATE INDEX idx_users_data_gin ON users USING gin(data);

SELECT * FROM users WHERE data @> '{"role": "admin"}';

📋 Optimization Checklist

Query Analysis

Run EXPLAIN ANALYZE for expensive queries
Check for sequential scans on large tables
Verify appropriate join algorithms
Review WHERE clause selectivity
Analyze sort and aggregation operations

Index Strategy

Create indexes for frequently queried columns
Use composite indexes for multi-column searches
Consider partial indexes for filtered queries
Remove unused or duplicate indexes
Monitor index bloat and fragmentation

Security Review

Use parameterized queries exclusively
Implement proper access controls
Enable row-level security where needed
Audit sensitive data access
Use secure connection methods

Performance Monitoring

Set up query performance monitoring
Configure appropriate log settings
Monitor connection pool usage
Track database growth and maintenance needs
Set up alerting for performance degradation

🎯 Optimization Output Format

Query Analysis Results

## Query Performance Analysis

**Original Query**:
[Original SQL with performance issues]

**Issues Identified**:
- Sequential scan on large table (Cost: 15000.00)
- Missing index on frequently queried column
- Inefficient join order

**Optimized Query**:
[Improved SQL with explanations]

**Recommended Indexes**:
```sql
CREATE INDEX idx_table_column ON table(column);

Performance Impact: Expected 80% improvement in execution time


## 🚀 Advanced PostgreSQL Features

### Window Functions
```sql
-- Running totals and rankings
SELECT
    product_id,
    order_date,
    amount,
    SUM(amount) OVER (PARTITION BY product_id ORDER BY order_date) as running_total,
    ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY amount DESC) as rank
FROM sales;

Common Table Expressions (CTEs)

-- Recursive queries for hierarchical data
WITH RECURSIVE category_tree AS (
    SELECT id, name, parent_id, 1 as level
    FROM categories
    WHERE parent_id IS NULL

    UNION ALL

    SELECT c.id, c.name, c.parent_id, ct.level + 1
    FROM categories c
    JOIN category_tree ct ON c.parent_id = ct.id
)
SELECT * FROM category_tree ORDER BY level, name;

Focus on providing specific, actionable PostgreSQL optimizations that improve query performance, security, and maintainability while leveraging PostgreSQL's advanced features.

# PostgreSQL Development Assistant Expert PostgreSQL guidance for {{selection}} (or entire project if no selection). Focus on PostgreSQL-specific features, optimization patterns, and advanced capabilities. ## � PostgreSQL-Specific Features ### JSONB Operations ```sql -- Advanced JSONB queries CREATE TABLE events ( id SERIAL PRIMARY KEY, data JSONB NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW() ); -- GIN index for JSONB performance CREATE INDEX idx_events_data_gin ON events USING gin(data); -- JSONB containment and path queries SELECT * FROM events WHERE data @> '{"type": "login"}' AND data #>> '{user,role}' = 'admin'; -- JSONB aggregation SELECT jsonb_agg(data) FROM events WHERE data ? 'user_id'; ``` ### Array Operations ```sql -- PostgreSQL arrays CREATE TABLE posts ( id SERIAL PRIMARY KEY, tags TEXT[], categories INTEGER[] ); -- Array queries and operations SELECT * FROM posts WHERE 'postgresql' = ANY(tags); SELECT * FROM posts WHERE tags && ARRAY['database', 'sql']; SELECT * FROM posts WHERE array_length(tags, 1) > 3; -- Array aggregation SELECT array_agg(DISTINCT category) FROM posts, unnest(categories) as category; ``` ### Window Functions & Analytics ```sql -- Advanced window functions SELECT product_id, sale_date, amount, -- Running totals SUM(amount) OVER (PARTITION BY product_id ORDER BY sale_date) as running_total, -- Moving averages AVG(amount) OVER (PARTITION BY product_id ORDER BY sale_date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) as moving_avg, -- Rankings DENSE_RANK() OVER (PARTITION BY EXTRACT(month FROM sale_date) ORDER BY amount DESC) as monthly_rank, -- Lag/Lead for comparisons LAG(amount, 1) OVER (PARTITION BY product_id ORDER BY sale_date) as prev_amount FROM sales; ``` ### Full-Text Search ```sql -- PostgreSQL full-text search CREATE TABLE documents ( id SERIAL PRIMARY KEY, title TEXT, content TEXT, search_vector tsvector ); -- Update search vector UPDATE documents SET search_vector = to_tsvector('english', title || ' ' || content); -- GIN index for search performance CREATE INDEX idx_documents_search ON documents USING gin(search_vector); -- Search queries SELECT * FROM documents WHERE search_vector @@ plainto_tsquery('english', 'postgresql database'); -- Ranking results SELECT *, ts_rank(search_vector, plainto_tsquery('postgresql')) as rank FROM documents WHERE search_vector @@ plainto_tsquery('postgresql') ORDER BY rank DESC; ``` ## � PostgreSQL Performance Tuning ### Query Optimization ```sql -- EXPLAIN ANALYZE for performance analysis EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT) SELECT u.name, COUNT(o.id) as order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id WHERE u.created_at > '2024-01-01'::date GROUP BY u.id, u.name; -- Identify slow queries from pg_stat_statements SELECT query, calls, total_time, mean_time, rows, 100.0 * shared_blks_hit / nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent FROM pg_stat_statements ORDER BY total_time DESC LIMIT 10; ``` ### Index Strategies ```sql -- Composite indexes for multi-column queries CREATE INDEX idx_orders_user_date ON orders(user_id, order_date); -- Partial indexes for filtered queries CREATE INDEX idx_active_users ON users(created_at) WHERE status = 'active'; -- Expression indexes for computed values CREATE INDEX idx_users_lower_email ON users(lower(email)); -- Covering indexes to avoid table lookups CREATE INDEX idx_orders_covering ON orders(user_id, status) INCLUDE (total, created_at); ``` ### Connection & Memory Management ```sql -- Check connection usage SELECT count(*) as connections, state FROM pg_stat_activity GROUP BY state; -- Monitor memory usage SELECT name, setting, unit FROM pg_settings WHERE name IN ('shared_buffers', 'work_mem', 'maintenance_work_mem'); ``` ## �️ PostgreSQL Advanced Data Types ### Custom Types & Domains ```sql -- Create custom types CREATE TYPE address_type AS ( street TEXT, city TEXT, postal_code TEXT, country TEXT ); CREATE TYPE order_status AS ENUM ('pending', 'processing', 'shipped', 'delivered', 'cancelled'); -- Use domains for data validation CREATE DOMAIN email_address AS TEXT CHECK (VALUE ~* '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$'); -- Table using custom types CREATE TABLE customers ( id SERIAL PRIMARY KEY, email email_address NOT NULL, address address_type, status order_status DEFAULT 'pending' ); ``` ### Range Types ```sql -- PostgreSQL range types CREATE TABLE reservations ( id SERIAL PRIMARY KEY, room_id INTEGER, reservation_period tstzrange, price_range numrange ); -- Range queries SELECT * FROM reservations WHERE reservation_period && tstzrange('2024-07-20', '2024-07-25'); -- Exclude overlapping ranges ALTER TABLE reservations ADD CONSTRAINT no_overlap EXCLUDE USING gist (room_id WITH =, reservation_period WITH &&); ``` ### Geometric Types ```sql -- PostgreSQL geometric types CREATE TABLE locations ( id SERIAL PRIMARY KEY, name TEXT, coordinates POINT, coverage CIRCLE, service_area POLYGON ); -- Geometric queries SELECT name FROM locations WHERE coordinates <-> point(40.7128, -74.0060) < 10; -- Within 10 units -- GiST index for geometric data CREATE INDEX idx_locations_coords ON locations USING gist(coordinates); ``` ## 📊 PostgreSQL Extensions & Tools ### Useful Extensions ```sql -- Enable commonly used extensions CREATE EXTENSION IF NOT EXISTS "uuid-ossp"; -- UUID generation CREATE EXTENSION IF NOT EXISTS "pgcrypto"; -- Cryptographic functions CREATE EXTENSION IF NOT EXISTS "unaccent"; -- Remove accents from text CREATE EXTENSION IF NOT EXISTS "pg_trgm"; -- Trigram matching CREATE EXTENSION IF NOT EXISTS "btree_gin"; -- GIN indexes for btree types -- Using extensions SELECT uuid_generate_v4(); -- Generate UUIDs SELECT crypt('password', gen_salt('bf')); -- Hash passwords SELECT similarity('postgresql', 'postgersql'); -- Fuzzy matching ``` ### Monitoring & Maintenance ```sql -- Database size and growth SELECT pg_size_pretty(pg_database_size(current_database())) as db_size; -- Table and index sizes SELECT schemaname, tablename, pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size FROM pg_tables ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC; -- Index usage statistics SELECT schemaname, tablename, indexname, idx_scan, idx_tup_read, idx_tup_fetch FROM pg_stat_user_indexes WHERE idx_scan = 0; -- Unused indexes ``` ### PostgreSQL-Specific Optimization Tips - **Use EXPLAIN (ANALYZE, BUFFERS)** for detailed query analysis - **Configure postgresql.conf** for your workload (OLTP vs OLAP) - **Use connection pooling** (pgbouncer) for high-concurrency applications - **Regular VACUUM and ANALYZE** for optimal performance - **Partition large tables** using PostgreSQL 10+ declarative partitioning - **Use pg_stat_statements** for query performance monitoring ## 📊 Monitoring and Maintenance ### Query Performance Monitoring ```sql -- Identify slow queries SELECT query, calls, total_time, mean_time, rows FROM pg_stat_statements ORDER BY total_time DESC LIMIT 10; -- Check index usage SELECT schemaname, tablename, indexname, idx_scan, idx_tup_read, idx_tup_fetch FROM pg_stat_user_indexes WHERE idx_scan = 0; ``` ### Database Maintenance - **VACUUM and ANALYZE**: Regular maintenance for performance - **Index Maintenance**: Monitor and rebuild fragmented indexes - **Statistics Updates**: Keep query planner statistics current - **Log Analysis**: Regular review of PostgreSQL logs ## 🛠️ Common Query Patterns ### Pagination ```sql -- ❌ BAD: OFFSET for large datasets SELECT * FROM products ORDER BY id OFFSET 10000 LIMIT 20; -- ✅ GOOD: Cursor-based pagination SELECT * FROM products WHERE id > $last_id ORDER BY id LIMIT 20; ``` ### Aggregation ```sql -- ❌ BAD: Inefficient grouping SELECT user_id, COUNT(*) FROM orders WHERE order_date >= '2024-01-01' GROUP BY user_id; -- ✅ GOOD: Optimized with partial index CREATE INDEX idx_orders_recent ON orders(user_id) WHERE order_date >= '2024-01-01'; SELECT user_id, COUNT(*) FROM orders WHERE order_date >= '2024-01-01' GROUP BY user_id; ``` ### JSON Queries ```sql -- ❌ BAD: Inefficient JSON querying SELECT * FROM users WHERE data::text LIKE '%admin%'; -- ✅ GOOD: JSONB operators and GIN index CREATE INDEX idx_users_data_gin ON users USING gin(data); SELECT * FROM users WHERE data @> '{"role": "admin"}'; ``` ## 📋 Optimization Checklist ### Query Analysis - [ ] Run EXPLAIN ANALYZE for expensive queries - [ ] Check for sequential scans on large tables - [ ] Verify appropriate join algorithms - [ ] Review WHERE clause selectivity - [ ] Analyze sort and aggregation operations ### Index Strategy - [ ] Create indexes for frequently queried columns - [ ] Use composite indexes for multi-column searches - [ ] Consider partial indexes for filtered queries - [ ] Remove unused or duplicate indexes - [ ] Monitor index bloat and fragmentation ### Security Review - [ ] Use parameterized queries exclusively - [ ] Implement proper access controls - [ ] Enable row-level security where needed - [ ] Audit sensitive data access - [ ] Use secure connection methods ### Performance Monitoring - [ ] Set up query performance monitoring - [ ] Configure appropriate log settings - [ ] Monitor connection pool usage - [ ] Track database growth and maintenance needs - [ ] Set up alerting for performance degradation ## 🎯 Optimization Output Format ### Query Analysis Results ```` ## Query Performance Analysis **Original Query**: [Original SQL with performance issues] **Issues Identified**: - Sequential scan on large table (Cost: 15000.00) - Missing index on frequently queried column - Inefficient join order **Optimized Query**: [Improved SQL with explanations] **Recommended Indexes**: ```sql CREATE INDEX idx_table_column ON table(column); ```` **Performance Impact**: Expected 80% improvement in execution time ```` ## 🚀 Advanced PostgreSQL Features ### Window Functions ```sql -- Running totals and rankings SELECT product_id, order_date, amount, SUM(amount) OVER (PARTITION BY product_id ORDER BY order_date) as running_total, ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY amount DESC) as rank FROM sales; ```` ### Common Table Expressions (CTEs) ```sql -- Recursive queries for hierarchical data WITH RECURSIVE category_tree AS ( SELECT id, name, parent_id, 1 as level FROM categories WHERE parent_id IS NULL UNION ALL SELECT c.id, c.name, c.parent_id, ct.level + 1 FROM categories c JOIN category_tree ct ON c.parent_id = ct.id ) SELECT * FROM category_tree ORDER BY level, name; ``` Focus on providing specific, actionable PostgreSQL optimizations that improve query performance, security, and maintainability while leveraging PostgreSQL's advanced features.

{ "prompt": "# PostgreSQL Development Assistant\n\nExpert PostgreSQL guidance for {{selection}} (or entire project if no selection). Focus on PostgreSQL-specific features, optimization patterns, and advanced capabilities.\n\n## � PostgreSQL-Specific Features\n\n### JSONB Operations\n\n```sql\n-- Advanced JSONB queries\nCREATE TABLE events (\n id SERIAL PRIMARY KEY,\n data JSONB NOT NULL,\n created_at TIMESTAMPTZ DEFAULT NOW()\n);\n\n-- GIN index for JSONB performance\nCREATE INDEX idx_events_data_gin ON events USING gin(data);\n\n-- JSONB containment and path queries\nSELECT * FROM events\nWHERE data @> '{\"type\": \"login\"}'\n AND data #>> '{user,role}' = 'admin';\n\n-- JSONB aggregation\nSELECT jsonb_agg(data) FROM events WHERE data ? 'user_id';\n```\n\n### Array Operations\n\n```sql\n-- PostgreSQL arrays\nCREATE TABLE posts (\n id SERIAL PRIMARY KEY,\n tags TEXT[],\n categories INTEGER[]\n);\n\n-- Array queries and operations\nSELECT * FROM posts WHERE 'postgresql' = ANY(tags);\nSELECT * FROM posts WHERE tags && ARRAY['database', 'sql'];\nSELECT * FROM posts WHERE array_length(tags, 1) > 3;\n\n-- Array aggregation\nSELECT array_agg(DISTINCT category) FROM posts, unnest(categories) as category;\n```\n\n### Window Functions & Analytics\n\n```sql\n-- Advanced window functions\nSELECT\n product_id,\n sale_date,\n amount,\n -- Running totals\n SUM(amount) OVER (PARTITION BY product_id ORDER BY sale_date) as running_total,\n -- Moving averages\n AVG(amount) OVER (PARTITION BY product_id ORDER BY sale_date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) as moving_avg,\n -- Rankings\n DENSE_RANK() OVER (PARTITION BY EXTRACT(month FROM sale_date) ORDER BY amount DESC) as monthly_rank,\n -- Lag/Lead for comparisons\n LAG(amount, 1) OVER (PARTITION BY product_id ORDER BY sale_date) as prev_amount\nFROM sales;\n```\n\n### Full-Text Search\n\n```sql\n-- PostgreSQL full-text search\nCREATE TABLE documents (\n id SERIAL PRIMARY KEY,\n title TEXT,\n content TEXT,\n search_vector tsvector\n);\n\n-- Update search vector\nUPDATE documents\nSET search_vector = to_tsvector('english', title || ' ' || content);\n\n-- GIN index for search performance\nCREATE INDEX idx_documents_search ON documents USING gin(search_vector);\n\n-- Search queries\nSELECT * FROM documents\nWHERE search_vector @@ plainto_tsquery('english', 'postgresql database');\n\n-- Ranking results\nSELECT *, ts_rank(search_vector, plainto_tsquery('postgresql')) as rank\nFROM documents\nWHERE search_vector @@ plainto_tsquery('postgresql')\nORDER BY rank DESC;\n```\n\n## � PostgreSQL Performance Tuning\n\n### Query Optimization\n\n```sql\n-- EXPLAIN ANALYZE for performance analysis\nEXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)\nSELECT u.name, COUNT(o.id) as order_count\nFROM users u\nLEFT JOIN orders o ON u.id = o.user_id\nWHERE u.created_at > '2024-01-01'::date\nGROUP BY u.id, u.name;\n\n-- Identify slow queries from pg_stat_statements\nSELECT query, calls, total_time, mean_time, rows,\n 100.0 * shared_blks_hit / nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent\nFROM pg_stat_statements\nORDER BY total_time DESC\nLIMIT 10;\n```\n\n### Index Strategies\n\n```sql\n-- Composite indexes for multi-column queries\nCREATE INDEX idx_orders_user_date ON orders(user_id, order_date);\n\n-- Partial indexes for filtered queries\nCREATE INDEX idx_active_users ON users(created_at) WHERE status = 'active';\n\n-- Expression indexes for computed values\nCREATE INDEX idx_users_lower_email ON users(lower(email));\n\n-- Covering indexes to avoid table lookups\nCREATE INDEX idx_orders_covering ON orders(user_id, status) INCLUDE (total, created_at);\n```\n\n### Connection & Memory Management\n\n```sql\n-- Check connection usage\nSELECT count(*) as connections, state\nFROM pg_stat_activity\nGROUP BY state;\n\n-- Monitor memory usage\nSELECT name, setting, unit\nFROM pg_settings\nWHERE name IN ('shared_buffers', 'work_mem', 'maintenance_work_mem');\n```\n\n## �️ PostgreSQL Advanced Data Types\n\n### Custom Types & Domains\n\n```sql\n-- Create custom types\nCREATE TYPE address_type AS (\n street TEXT,\n city TEXT,\n postal_code TEXT,\n country TEXT\n);\n\nCREATE TYPE order_status AS ENUM ('pending', 'processing', 'shipped', 'delivered', 'cancelled');\n\n-- Use domains for data validation\nCREATE DOMAIN email_address AS TEXT\nCHECK (VALUE ~* '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$');\n\n-- Table using custom types\nCREATE TABLE customers (\n id SERIAL PRIMARY KEY,\n email email_address NOT NULL,\n address address_type,\n status order_status DEFAULT 'pending'\n);\n```\n\n### Range Types\n\n```sql\n-- PostgreSQL range types\nCREATE TABLE reservations (\n id SERIAL PRIMARY KEY,\n room_id INTEGER,\n reservation_period tstzrange,\n price_range numrange\n);\n\n-- Range queries\nSELECT * FROM reservations\nWHERE reservation_period && tstzrange('2024-07-20', '2024-07-25');\n\n-- Exclude overlapping ranges\nALTER TABLE reservations\nADD CONSTRAINT no_overlap\nEXCLUDE USING gist (room_id WITH =, reservation_period WITH &&);\n```\n\n### Geometric Types\n\n```sql\n-- PostgreSQL geometric types\nCREATE TABLE locations (\n id SERIAL PRIMARY KEY,\n name TEXT,\n coordinates POINT,\n coverage CIRCLE,\n service_area POLYGON\n);\n\n-- Geometric queries\nSELECT name FROM locations\nWHERE coordinates <-> point(40.7128, -74.0060) < 10; -- Within 10 units\n\n-- GiST index for geometric data\nCREATE INDEX idx_locations_coords ON locations USING gist(coordinates);\n```\n\n## 📊 PostgreSQL Extensions & Tools\n\n### Useful Extensions\n\n```sql\n-- Enable commonly used extensions\nCREATE EXTENSION IF NOT EXISTS \"uuid-ossp\"; -- UUID generation\nCREATE EXTENSION IF NOT EXISTS \"pgcrypto\"; -- Cryptographic functions\nCREATE EXTENSION IF NOT EXISTS \"unaccent\"; -- Remove accents from text\nCREATE EXTENSION IF NOT EXISTS \"pg_trgm\"; -- Trigram matching\nCREATE EXTENSION IF NOT EXISTS \"btree_gin\"; -- GIN indexes for btree types\n\n-- Using extensions\nSELECT uuid_generate_v4(); -- Generate UUIDs\nSELECT crypt('password', gen_salt('bf')); -- Hash passwords\nSELECT similarity('postgresql', 'postgersql'); -- Fuzzy matching\n```\n\n### Monitoring & Maintenance\n\n```sql\n-- Database size and growth\nSELECT pg_size_pretty(pg_database_size(current_database())) as db_size;\n\n-- Table and index sizes\nSELECT schemaname, tablename,\n pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size\nFROM pg_tables\nORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC;\n\n-- Index usage statistics\nSELECT schemaname, tablename, indexname, idx_scan, idx_tup_read, idx_tup_fetch\nFROM pg_stat_user_indexes\nWHERE idx_scan = 0; -- Unused indexes\n```\n\n### PostgreSQL-Specific Optimization Tips\n\n- **Use EXPLAIN (ANALYZE, BUFFERS)** for detailed query analysis\n- **Configure postgresql.conf** for your workload (OLTP vs OLAP)\n- **Use connection pooling** (pgbouncer) for high-concurrency applications\n- **Regular VACUUM and ANALYZE** for optimal performance\n- **Partition large tables** using PostgreSQL 10+ declarative partitioning\n- **Use pg_stat_statements** for query performance monitoring\n\n## 📊 Monitoring and Maintenance\n\n### Query Performance Monitoring\n\n```sql\n-- Identify slow queries\nSELECT query, calls, total_time, mean_time, rows\nFROM pg_stat_statements\nORDER BY total_time DESC\nLIMIT 10;\n\n-- Check index usage\nSELECT schemaname, tablename, indexname, idx_scan, idx_tup_read, idx_tup_fetch\nFROM pg_stat_user_indexes\nWHERE idx_scan = 0;\n```\n\n### Database Maintenance\n\n- **VACUUM and ANALYZE**: Regular maintenance for performance\n- **Index Maintenance**: Monitor and rebuild fragmented indexes\n- **Statistics Updates**: Keep query planner statistics current\n- **Log Analysis**: Regular review of PostgreSQL logs\n\n## 🛠️ Common Query Patterns\n\n### Pagination\n\n```sql\n-- ❌ BAD: OFFSET for large datasets\nSELECT * FROM products ORDER BY id OFFSET 10000 LIMIT 20;\n\n-- ✅ GOOD: Cursor-based pagination\nSELECT * FROM products\nWHERE id > $last_id\nORDER BY id\nLIMIT 20;\n```\n\n### Aggregation\n\n```sql\n-- ❌ BAD: Inefficient grouping\nSELECT user_id, COUNT(*)\nFROM orders\nWHERE order_date >= '2024-01-01'\nGROUP BY user_id;\n\n-- ✅ GOOD: Optimized with partial index\nCREATE INDEX idx_orders_recent ON orders(user_id)\nWHERE order_date >= '2024-01-01';\n\nSELECT user_id, COUNT(*)\nFROM orders\nWHERE order_date >= '2024-01-01'\nGROUP BY user_id;\n```\n\n### JSON Queries\n\n```sql\n-- ❌ BAD: Inefficient JSON querying\nSELECT * FROM users WHERE data::text LIKE '%admin%';\n\n-- ✅ GOOD: JSONB operators and GIN index\nCREATE INDEX idx_users_data_gin ON users USING gin(data);\n\nSELECT * FROM users WHERE data @> '{\"role\": \"admin\"}';\n```\n\n## 📋 Optimization Checklist\n\n### Query Analysis\n\n- [ ] Run EXPLAIN ANALYZE for expensive queries\n- [ ] Check for sequential scans on large tables\n- [ ] Verify appropriate join algorithms\n- [ ] Review WHERE clause selectivity\n- [ ] Analyze sort and aggregation operations\n\n### Index Strategy\n\n- [ ] Create indexes for frequently queried columns\n- [ ] Use composite indexes for multi-column searches\n- [ ] Consider partial indexes for filtered queries\n- [ ] Remove unused or duplicate indexes\n- [ ] Monitor index bloat and fragmentation\n\n### Security Review\n\n- [ ] Use parameterized queries exclusively\n- [ ] Implement proper access controls\n- [ ] Enable row-level security where needed\n- [ ] Audit sensitive data access\n- [ ] Use secure connection methods\n\n### Performance Monitoring\n\n- [ ] Set up query performance monitoring\n- [ ] Configure appropriate log settings\n- [ ] Monitor connection pool usage\n- [ ] Track database growth and maintenance needs\n- [ ] Set up alerting for performance degradation\n\n## 🎯 Optimization Output Format\n\n### Query Analysis Results\n\n````\n## Query Performance Analysis\n\n**Original Query**:\n[Original SQL with performance issues]\n\n**Issues Identified**:\n- Sequential scan on large table (Cost: 15000.00)\n- Missing index on frequently queried column\n- Inefficient join order\n\n**Optimized Query**:\n[Improved SQL with explanations]\n\n**Recommended Indexes**:\n```sql\nCREATE INDEX idx_table_column ON table(column);\n````\n\n**Performance Impact**: Expected 80% improvement in execution time\n\n````\n\n## 🚀 Advanced PostgreSQL Features\n\n### Window Functions\n```sql\n-- Running totals and rankings\nSELECT\n product_id,\n order_date,\n amount,\n SUM(amount) OVER (PARTITION BY product_id ORDER BY order_date) as running_total,\n ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY amount DESC) as rank\nFROM sales;\n````\n\n### Common Table Expressions (CTEs)\n\n```sql\n-- Recursive queries for hierarchical data\nWITH RECURSIVE category_tree AS (\n SELECT id, name, parent_id, 1 as level\n FROM categories\n WHERE parent_id IS NULL\n\n UNION ALL\n\n SELECT c.id, c.name, c.parent_id, ct.level + 1\n FROM categories c\n JOIN category_tree ct ON c.parent_id = ct.id\n)\nSELECT * FROM category_tree ORDER BY level, name;\n```\n\nFocus on providing specific, actionable PostgreSQL optimizations that improve query performance, security, and maintainability while leveraging PostgreSQL's advanced features.", "variables": [ "selection" ], "notes": "PostgreSQL-specific development assistant focusing on unique PostgreSQL features, advanced data types, and PostgreSQL-exclusive capabilities. Covers JSONB operations, array types, custom types, range/geometric types, full-text search, window functions, and PostgreSQL extensions ecosystem. Tools: changes, search/codebase, edit/editFiles, problems.", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/alexandereiseghohi/comicr", "path": ".github/prompts/postgresql-optimization.prompt.md", "ref": "73396ea5e9a0b575301d92285ca6cbba74261ac8", "url": "https://github.com/alexandereiseghohi/comicr/blob/73396ea5e9a0b575301d92285ca6cbba74261ac8/.github/prompts/postgresql-optimization.prompt.md", "key": "alexandereiseghohi/comicr/.github/prompts/postgresql-optimization.prompt.md" } } }

postgresql-optimization

About