@dotdo/postgres 0.1.0

package/src/playground/sample-queries.ts

@@ -0,0 +1,1168 @@
+/**
+ * Sample Queries for Playground
+ *
+ * Provides pre-built sample queries for common SQL operations,
+ * organized by category for easy discovery and learning.
+ *
+ * @module playground/sample-queries
+ */
+
+/**
+ * A sample query with metadata
+ */
+export interface SampleQuery {
+  /** Unique identifier for the query */
+  id: string
+  /** Display name/title */
+  name: string
+  /** Category for grouping */
+  category: SampleQueryCategory
+  /** Brief description of what the query does */
+  description: string
+  /** The SQL query */
+  sql: string
+  /** Optional parameters for parameterized queries */
+  params?: unknown[]
+  /** Tags for filtering/searching */
+  tags?: string[]
+  /** Difficulty level */
+  difficulty?: 'beginner' | 'intermediate' | 'advanced'
+  /** Whether this query requires sample data to be loaded first */
+  requiresSampleData?: boolean
+}
+
+/**
+ * Categories for organizing sample queries
+ */
+export type SampleQueryCategory =
+  | 'basic-select'
+  | 'filtering'
+  | 'aggregation'
+  | 'joins'
+  | 'subqueries'
+  | 'data-modification'
+  | 'ddl'
+  | 'window-functions'
+  | 'json'
+  | 'text-search'
+  | 'date-time'
+  | 'advanced'
+
+/**
+ * Category metadata for display
+ */
+export interface SampleQueryCategoryInfo {
+  id: SampleQueryCategory
+  name: string
+  description: string
+  icon?: string
+}
+
+/**
+ * Category information
+ */
+export const SAMPLE_QUERY_CATEGORIES: SampleQueryCategoryInfo[] = [
+  {
+    id: 'basic-select',
+    name: 'Basic SELECT',
+    description: 'Fundamental SELECT queries to retrieve data',
+  },
+  {
+    id: 'filtering',
+    name: 'Filtering & Sorting',
+    description: 'WHERE clauses, ORDER BY, and LIMIT',
+  },
+  {
+    id: 'aggregation',
+    name: 'Aggregation',
+    description: 'GROUP BY, COUNT, SUM, AVG, and other aggregate functions',
+  },
+  {
+    id: 'joins',
+    name: 'Joins',
+    description: 'INNER JOIN, LEFT JOIN, and other join types',
+  },
+  {
+    id: 'subqueries',
+    name: 'Subqueries',
+    description: 'Nested queries, CTEs, and derived tables',
+  },
+  {
+    id: 'data-modification',
+    name: 'Data Modification',
+    description: 'INSERT, UPDATE, DELETE operations',
+  },
+  {
+    id: 'ddl',
+    name: 'Schema (DDL)',
+    description: 'CREATE, ALTER, DROP tables and indexes',
+  },
+  {
+    id: 'window-functions',
+    name: 'Window Functions',
+    description: 'ROW_NUMBER, RANK, LAG, LEAD, and partitioning',
+  },
+  {
+    id: 'json',
+    name: 'JSON Operations',
+    description: 'JSONB queries, operators, and functions',
+  },
+  {
+    id: 'text-search',
+    name: 'Text & Search',
+    description: 'LIKE, ILIKE, pattern matching, and full-text search',
+  },
+  {
+    id: 'date-time',
+    name: 'Date & Time',
+    description: 'Date/time functions, intervals, and formatting',
+  },
+  {
+    id: 'advanced',
+    name: 'Advanced',
+    description: 'Complex queries and PostgreSQL-specific features',
+  },
+]
+
+/**
+ * All sample queries
+ */
+export const SAMPLE_QUERIES: SampleQuery[] = [
+  // ============================================================================
+  // Basic SELECT
+  // ============================================================================
+  {
+    id: 'basic-select-all',
+    name: 'Select All Rows',
+    category: 'basic-select',
+    description: 'Retrieve all columns and rows from a table',
+    sql: 'SELECT * FROM users;',
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['select', 'basic'],
+  },
+  {
+    id: 'basic-select-columns',
+    name: 'Select Specific Columns',
+    category: 'basic-select',
+    description: 'Retrieve only specific columns from a table',
+    sql: 'SELECT name, email FROM users;',
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['select', 'columns'],
+  },
+  {
+    id: 'basic-select-alias',
+    name: 'Column Aliases',
+    category: 'basic-select',
+    description: 'Rename columns in the result using AS',
+    sql: `SELECT
+  name AS user_name,
+  email AS contact_email,
+  created_at AS joined_date
+FROM users;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['select', 'alias', 'as'],
+  },
+  {
+    id: 'basic-select-distinct',
+    name: 'Select Distinct Values',
+    category: 'basic-select',
+    description: 'Remove duplicate rows from results',
+    sql: `SELECT DISTINCT user_id
+FROM posts
+ORDER BY user_id;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['select', 'distinct', 'unique'],
+  },
+  {
+    id: 'basic-select-expression',
+    name: 'Calculated Columns',
+    category: 'basic-select',
+    description: 'Create computed values in SELECT',
+    sql: `SELECT
+  1 + 1 AS addition,
+  10 * 5 AS multiplication,
+  UPPER('hello') AS uppercase,
+  NOW() AS current_time;`,
+    difficulty: 'beginner',
+    tags: ['select', 'expression', 'computed'],
+  },
+
+  // ============================================================================
+  // Filtering & Sorting
+  // ============================================================================
+  {
+    id: 'filter-where-equals',
+    name: 'Simple WHERE Clause',
+    category: 'filtering',
+    description: 'Filter rows with exact match',
+    sql: `SELECT * FROM users
+WHERE name = 'Alice Johnson';`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['where', 'filter', 'equals'],
+  },
+  {
+    id: 'filter-where-multiple',
+    name: 'Multiple Conditions (AND/OR)',
+    category: 'filtering',
+    description: 'Combine conditions with AND/OR',
+    sql: `SELECT * FROM posts
+WHERE published = true
+  AND user_id = 1;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['where', 'and', 'or', 'filter'],
+  },
+  {
+    id: 'filter-where-in',
+    name: 'IN Operator',
+    category: 'filtering',
+    description: 'Match against a list of values',
+    sql: `SELECT * FROM users
+WHERE id IN (1, 2, 3);`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['where', 'in', 'list'],
+  },
+  {
+    id: 'filter-where-between',
+    name: 'BETWEEN Range',
+    category: 'filtering',
+    description: 'Filter values within a range',
+    sql: `SELECT * FROM users
+WHERE id BETWEEN 2 AND 4;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['where', 'between', 'range'],
+  },
+  {
+    id: 'filter-where-null',
+    name: 'NULL Checks',
+    category: 'filtering',
+    description: 'Check for NULL or NOT NULL values',
+    sql: `-- Find posts with no body
+SELECT * FROM posts
+WHERE body IS NULL;
+
+-- Find posts with body
+SELECT * FROM posts
+WHERE body IS NOT NULL;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['where', 'null', 'is null'],
+  },
+  {
+    id: 'filter-order-by',
+    name: 'Sorting Results',
+    category: 'filtering',
+    description: 'Order results by one or more columns',
+    sql: `SELECT * FROM users
+ORDER BY name ASC;
+
+-- Multiple columns, mixed direction
+SELECT * FROM posts
+ORDER BY user_id ASC, created_at DESC;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['order by', 'sort', 'asc', 'desc'],
+  },
+  {
+    id: 'filter-limit-offset',
+    name: 'Pagination with LIMIT/OFFSET',
+    category: 'filtering',
+    description: 'Limit results and skip rows for pagination',
+    sql: `-- First page (5 results)
+SELECT * FROM posts
+ORDER BY id
+LIMIT 5;
+
+-- Second page (skip first 5)
+SELECT * FROM posts
+ORDER BY id
+LIMIT 5 OFFSET 5;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['limit', 'offset', 'pagination'],
+  },
+
+  // ============================================================================
+  // Aggregation
+  // ============================================================================
+  {
+    id: 'agg-count',
+    name: 'COUNT Rows',
+    category: 'aggregation',
+    description: 'Count total rows or non-null values',
+    sql: `-- Total users
+SELECT COUNT(*) AS total_users FROM users;
+
+-- Count non-null values
+SELECT COUNT(email) AS users_with_email FROM users;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['count', 'aggregate'],
+  },
+  {
+    id: 'agg-sum-avg',
+    name: 'SUM and AVG',
+    category: 'aggregation',
+    description: 'Calculate sum and average of numeric columns',
+    sql: `SELECT
+  COUNT(*) AS total_posts,
+  SUM(CASE WHEN published THEN 1 ELSE 0 END) AS published_count,
+  AVG(CASE WHEN published THEN 1 ELSE 0 END) * 100 AS published_pct
+FROM posts;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['sum', 'avg', 'average', 'aggregate'],
+  },
+  {
+    id: 'agg-min-max',
+    name: 'MIN and MAX',
+    category: 'aggregation',
+    description: 'Find minimum and maximum values',
+    sql: `SELECT
+  MIN(created_at) AS first_user,
+  MAX(created_at) AS latest_user
+FROM users;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['min', 'max', 'aggregate'],
+  },
+  {
+    id: 'agg-group-by',
+    name: 'GROUP BY',
+    category: 'aggregation',
+    description: 'Group rows and calculate aggregates per group',
+    sql: `SELECT
+  user_id,
+  COUNT(*) AS post_count,
+  SUM(CASE WHEN published THEN 1 ELSE 0 END) AS published
+FROM posts
+GROUP BY user_id
+ORDER BY post_count DESC;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['group by', 'aggregate', 'grouping'],
+  },
+  {
+    id: 'agg-having',
+    name: 'HAVING Clause',
+    category: 'aggregation',
+    description: 'Filter groups after aggregation',
+    sql: `SELECT
+  user_id,
+  COUNT(*) AS post_count
+FROM posts
+GROUP BY user_id
+HAVING COUNT(*) > 2
+ORDER BY post_count DESC;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['having', 'group by', 'filter'],
+  },
+
+  // ============================================================================
+  // Joins
+  // ============================================================================
+  {
+    id: 'join-inner',
+    name: 'INNER JOIN',
+    category: 'joins',
+    description: 'Combine rows from two tables where keys match',
+    sql: `SELECT
+  u.name AS author,
+  p.title,
+  p.published
+FROM posts p
+INNER JOIN users u ON u.id = p.user_id
+ORDER BY u.name, p.title;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['join', 'inner join'],
+  },
+  {
+    id: 'join-left',
+    name: 'LEFT JOIN',
+    category: 'joins',
+    description: 'Include all rows from left table, match from right',
+    sql: `SELECT
+  u.name,
+  COUNT(p.id) AS post_count
+FROM users u
+LEFT JOIN posts p ON p.user_id = u.id
+GROUP BY u.id, u.name
+ORDER BY post_count DESC;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['join', 'left join', 'outer'],
+  },
+  {
+    id: 'join-multiple',
+    name: 'Multiple Joins',
+    category: 'joins',
+    description: 'Join three or more tables',
+    sql: `SELECT
+  u.name AS commenter,
+  p.title AS post_title,
+  c.content AS comment
+FROM comments c
+JOIN users u ON u.id = c.user_id
+JOIN posts p ON p.id = c.post_id
+ORDER BY c.created_at DESC
+LIMIT 10;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['join', 'multiple', 'three tables'],
+  },
+  {
+    id: 'join-self',
+    name: 'Self Join',
+    category: 'joins',
+    description: 'Join a table to itself',
+    sql: `-- Find users who joined on the same day
+SELECT
+  u1.name AS user1,
+  u2.name AS user2,
+  DATE(u1.created_at) AS joined_date
+FROM users u1
+JOIN users u2 ON DATE(u1.created_at) = DATE(u2.created_at)
+  AND u1.id < u2.id
+ORDER BY joined_date;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['join', 'self join'],
+  },
+
+  // ============================================================================
+  // Subqueries
+  // ============================================================================
+  {
+    id: 'subquery-where',
+    name: 'Subquery in WHERE',
+    category: 'subqueries',
+    description: 'Use a subquery to filter results',
+    sql: `SELECT * FROM posts
+WHERE user_id IN (
+  SELECT id FROM users
+  WHERE name LIKE 'A%'
+);`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['subquery', 'nested', 'where'],
+  },
+  {
+    id: 'subquery-exists',
+    name: 'EXISTS Subquery',
+    category: 'subqueries',
+    description: 'Check if subquery returns any rows',
+    sql: `-- Users who have written at least one post
+SELECT * FROM users u
+WHERE EXISTS (
+  SELECT 1 FROM posts p
+  WHERE p.user_id = u.id
+);`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['subquery', 'exists', 'correlated'],
+  },
+  {
+    id: 'subquery-cte',
+    name: 'Common Table Expression (CTE)',
+    category: 'subqueries',
+    description: 'Use WITH clause for readable subqueries',
+    sql: `WITH user_post_counts AS (
+  SELECT
+    user_id,
+    COUNT(*) AS post_count
+  FROM posts
+  GROUP BY user_id
+)
+SELECT
+  u.name,
+  COALESCE(upc.post_count, 0) AS posts
+FROM users u
+LEFT JOIN user_post_counts upc ON upc.user_id = u.id
+ORDER BY posts DESC;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['cte', 'with', 'common table expression'],
+  },
+  {
+    id: 'subquery-derived-table',
+    name: 'Derived Table (FROM Subquery)',
+    category: 'subqueries',
+    description: 'Use a subquery as a table in FROM',
+    sql: `SELECT
+  stats.user_id,
+  u.name,
+  stats.total_posts,
+  stats.published_posts
+FROM (
+  SELECT
+    user_id,
+    COUNT(*) AS total_posts,
+    SUM(CASE WHEN published THEN 1 ELSE 0 END) AS published_posts
+  FROM posts
+  GROUP BY user_id
+) AS stats
+JOIN users u ON u.id = stats.user_id
+ORDER BY stats.total_posts DESC;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['subquery', 'derived table', 'from'],
+  },
+
+  // ============================================================================
+  // Data Modification
+  // ============================================================================
+  {
+    id: 'dml-insert-single',
+    name: 'INSERT Single Row',
+    category: 'data-modification',
+    description: 'Insert a single row into a table',
+    sql: `INSERT INTO users (name, email)
+VALUES ('New User', 'newuser@example.com')
+RETURNING *;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['insert', 'dml', 'returning'],
+  },
+  {
+    id: 'dml-insert-multiple',
+    name: 'INSERT Multiple Rows',
+    category: 'data-modification',
+    description: 'Insert several rows at once',
+    sql: `INSERT INTO users (name, email) VALUES
+  ('User A', 'usera@example.com'),
+  ('User B', 'userb@example.com'),
+  ('User C', 'userc@example.com')
+RETURNING id, name;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['insert', 'bulk', 'multiple'],
+  },
+  {
+    id: 'dml-update',
+    name: 'UPDATE Rows',
+    category: 'data-modification',
+    description: 'Update existing rows',
+    sql: `UPDATE posts
+SET published = true
+WHERE user_id = 1 AND published = false
+RETURNING id, title, published;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['update', 'dml', 'modify'],
+  },
+  {
+    id: 'dml-delete',
+    name: 'DELETE Rows',
+    category: 'data-modification',
+    description: 'Remove rows from a table',
+    sql: `-- Delete unpublished posts (example - be careful!)
+DELETE FROM posts
+WHERE published = false
+RETURNING id, title;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['delete', 'dml', 'remove'],
+  },
+  {
+    id: 'dml-upsert',
+    name: 'UPSERT (INSERT ON CONFLICT)',
+    category: 'data-modification',
+    description: 'Insert or update on conflict',
+    sql: `INSERT INTO users (name, email)
+VALUES ('Alice Johnson', 'alice@example.com')
+ON CONFLICT (email)
+DO UPDATE SET name = EXCLUDED.name
+RETURNING *;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['upsert', 'on conflict', 'merge'],
+  },
+
+  // ============================================================================
+  // DDL (Schema)
+  // ============================================================================
+  {
+    id: 'ddl-create-table',
+    name: 'CREATE TABLE',
+    category: 'ddl',
+    description: 'Create a new table with various column types',
+    sql: `CREATE TABLE IF NOT EXISTS products (
+  id SERIAL PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  price DECIMAL(10, 2) NOT NULL,
+  quantity INTEGER DEFAULT 0,
+  category TEXT,
+  created_at TIMESTAMP DEFAULT NOW(),
+  updated_at TIMESTAMP DEFAULT NOW()
+);`,
+    difficulty: 'beginner',
+    tags: ['create', 'table', 'ddl'],
+  },
+  {
+    id: 'ddl-alter-table',
+    name: 'ALTER TABLE',
+    category: 'ddl',
+    description: 'Modify table structure',
+    sql: `-- Add a column
+ALTER TABLE products ADD COLUMN sku TEXT UNIQUE;
+
+-- Drop a column
+-- ALTER TABLE products DROP COLUMN sku;
+
+-- Add a constraint
+ALTER TABLE products
+ADD CONSTRAINT price_positive CHECK (price >= 0);`,
+    difficulty: 'intermediate',
+    tags: ['alter', 'table', 'ddl', 'modify'],
+  },
+  {
+    id: 'ddl-create-index',
+    name: 'CREATE INDEX',
+    category: 'ddl',
+    description: 'Create indexes for better query performance',
+    sql: `-- Simple index
+CREATE INDEX IF NOT EXISTS idx_posts_user_id
+ON posts(user_id);
+
+-- Composite index
+CREATE INDEX IF NOT EXISTS idx_posts_user_published
+ON posts(user_id, published);
+
+-- Partial index
+CREATE INDEX IF NOT EXISTS idx_posts_published_only
+ON posts(created_at)
+WHERE published = true;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['index', 'ddl', 'performance'],
+  },
+  {
+    id: 'ddl-create-view',
+    name: 'CREATE VIEW',
+    category: 'ddl',
+    description: 'Create a virtual table from a query',
+    sql: `CREATE OR REPLACE VIEW user_post_summary AS
+SELECT
+  u.id AS user_id,
+  u.name,
+  COUNT(p.id) AS total_posts,
+  SUM(CASE WHEN p.published THEN 1 ELSE 0 END) AS published_posts
+FROM users u
+LEFT JOIN posts p ON p.user_id = u.id
+GROUP BY u.id, u.name;
+
+-- Query the view
+SELECT * FROM user_post_summary;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['view', 'ddl', 'virtual table'],
+  },
+
+  // ============================================================================
+  // Window Functions
+  // ============================================================================
+  {
+    id: 'window-row-number',
+    name: 'ROW_NUMBER',
+    category: 'window-functions',
+    description: 'Assign sequential numbers to rows',
+    sql: `SELECT
+  ROW_NUMBER() OVER (ORDER BY created_at) AS row_num,
+  name,
+  created_at
+FROM users;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['window', 'row_number', 'ranking'],
+  },
+  {
+    id: 'window-rank',
+    name: 'RANK and DENSE_RANK',
+    category: 'window-functions',
+    description: 'Rank rows with ties handling',
+    sql: `WITH post_counts AS (
+  SELECT
+    user_id,
+    COUNT(*) AS post_count
+  FROM posts
+  GROUP BY user_id
+)
+SELECT
+  u.name,
+  pc.post_count,
+  RANK() OVER (ORDER BY pc.post_count DESC) AS rank,
+  DENSE_RANK() OVER (ORDER BY pc.post_count DESC) AS dense_rank
+FROM post_counts pc
+JOIN users u ON u.id = pc.user_id;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['window', 'rank', 'dense_rank', 'ranking'],
+  },
+  {
+    id: 'window-partition',
+    name: 'PARTITION BY',
+    category: 'window-functions',
+    description: 'Apply window function within groups',
+    sql: `SELECT
+  u.name AS author,
+  p.title,
+  p.created_at,
+  ROW_NUMBER() OVER (
+    PARTITION BY p.user_id
+    ORDER BY p.created_at
+  ) AS post_number
+FROM posts p
+JOIN users u ON u.id = p.user_id
+ORDER BY u.name, post_number;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['window', 'partition', 'grouping'],
+  },
+  {
+    id: 'window-lag-lead',
+    name: 'LAG and LEAD',
+    category: 'window-functions',
+    description: 'Access previous/next row values',
+    sql: `SELECT
+  name,
+  created_at,
+  LAG(name) OVER (ORDER BY created_at) AS prev_user,
+  LEAD(name) OVER (ORDER BY created_at) AS next_user
+FROM users
+ORDER BY created_at;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['window', 'lag', 'lead', 'previous', 'next'],
+  },
+  {
+    id: 'window-running-total',
+    name: 'Running Total',
+    category: 'window-functions',
+    description: 'Calculate cumulative sum',
+    sql: `SELECT
+  id,
+  title,
+  created_at,
+  COUNT(*) OVER (ORDER BY created_at) AS running_count,
+  SUM(CASE WHEN published THEN 1 ELSE 0 END) OVER (
+    ORDER BY created_at
+  ) AS running_published
+FROM posts
+ORDER BY created_at;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['window', 'running total', 'cumulative'],
+  },
+
+  // ============================================================================
+  // JSON Operations
+  // ============================================================================
+  {
+    id: 'json-create',
+    name: 'Create JSON Data',
+    category: 'json',
+    description: 'Build JSON objects and arrays',
+    sql: `SELECT
+  jsonb_build_object(
+    'name', 'Alice',
+    'age', 30,
+    'active', true
+  ) AS json_object,
+  jsonb_build_array(1, 2, 3, 'four') AS json_array,
+  to_jsonb(ROW('hello', 42)) AS row_to_json;`,
+    difficulty: 'intermediate',
+    tags: ['json', 'jsonb', 'create'],
+  },
+  {
+    id: 'json-query',
+    name: 'Query JSON Fields',
+    category: 'json',
+    description: 'Extract values from JSON columns',
+    sql: `-- Create a table with JSON
+CREATE TABLE IF NOT EXISTS json_demo (
+  id SERIAL PRIMARY KEY,
+  data JSONB
+);
+
+INSERT INTO json_demo (data) VALUES
+  ('{"name": "Alice", "tags": ["admin", "user"], "meta": {"age": 30}}'),
+  ('{"name": "Bob", "tags": ["user"], "meta": {"age": 25}}')
+ON CONFLICT DO NOTHING;
+
+-- Query JSON fields
+SELECT
+  data->>'name' AS name,
+  data->'meta'->>'age' AS age,
+  data->'tags' AS tags,
+  jsonb_array_length(data->'tags') AS tag_count
+FROM json_demo;`,
+    difficulty: 'intermediate',
+    tags: ['json', 'jsonb', 'query', 'extract'],
+  },
+  {
+    id: 'json-filter',
+    name: 'Filter by JSON Values',
+    category: 'json',
+    description: 'Use JSON operators in WHERE clauses',
+    sql: `-- Filter by JSON field value
+SELECT * FROM json_demo
+WHERE data->>'name' = 'Alice';
+
+-- Check if array contains value
+SELECT * FROM json_demo
+WHERE data->'tags' ? 'admin';
+
+-- Check nested value
+SELECT * FROM json_demo
+WHERE (data->'meta'->>'age')::int > 25;`,
+    difficulty: 'intermediate',
+    tags: ['json', 'jsonb', 'filter', 'where'],
+  },
+  {
+    id: 'json-modify',
+    name: 'Modify JSON Data',
+    category: 'json',
+    description: 'Update JSON values and merge objects',
+    sql: `-- Update a JSON field
+UPDATE json_demo
+SET data = jsonb_set(data, '{meta,active}', 'true')
+WHERE data->>'name' = 'Alice'
+RETURNING *;
+
+-- Merge JSON objects
+SELECT
+  data || '{"status": "verified"}'::jsonb AS merged
+FROM json_demo;`,
+    difficulty: 'advanced',
+    tags: ['json', 'jsonb', 'update', 'modify'],
+  },
+
+  // ============================================================================
+  // Text & Search
+  // ============================================================================
+  {
+    id: 'text-like',
+    name: 'LIKE Pattern Matching',
+    category: 'text-search',
+    description: 'Search with wildcards',
+    sql: `-- Starts with
+SELECT * FROM users WHERE name LIKE 'A%';
+
+-- Contains
+SELECT * FROM users WHERE email LIKE '%example%';
+
+-- Case-insensitive
+SELECT * FROM users WHERE name ILIKE '%alice%';`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['like', 'ilike', 'pattern', 'search'],
+  },
+  {
+    id: 'text-regex',
+    name: 'Regular Expressions',
+    category: 'text-search',
+    description: 'Use regex for pattern matching',
+    sql: `-- Match pattern
+SELECT * FROM users
+WHERE email ~ '^[a-z]+@example\\.com$';
+
+-- Case-insensitive regex
+SELECT * FROM users
+WHERE name ~* '^(alice|bob)';`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['regex', 'pattern', 'search', 'regular expression'],
+  },
+  {
+    id: 'text-functions',
+    name: 'String Functions',
+    category: 'text-search',
+    description: 'Common string manipulation functions',
+    sql: `SELECT
+  name,
+  UPPER(name) AS upper_name,
+  LOWER(name) AS lower_name,
+  LENGTH(name) AS name_length,
+  SUBSTRING(name, 1, 5) AS first_five,
+  REPLACE(email, '@', ' [at] ') AS obfuscated_email,
+  TRIM('  hello  ') AS trimmed,
+  CONCAT(name, ' <', email, '>') AS formatted
+FROM users;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['string', 'text', 'functions'],
+  },
+  {
+    id: 'text-fulltext',
+    name: 'Full-Text Search',
+    category: 'text-search',
+    description: 'PostgreSQL full-text search capabilities',
+    sql: `-- Simple text search
+SELECT title, body
+FROM posts
+WHERE to_tsvector('english', title || ' ' || COALESCE(body, ''))
+  @@ to_tsquery('english', 'post');
+
+-- Ranked search results
+SELECT
+  title,
+  ts_rank(
+    to_tsvector('english', title || ' ' || COALESCE(body, '')),
+    to_tsquery('english', 'post')
+  ) AS rank
+FROM posts
+WHERE to_tsvector('english', title || ' ' || COALESCE(body, ''))
+  @@ to_tsquery('english', 'post')
+ORDER BY rank DESC;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['full-text', 'search', 'tsvector', 'tsquery'],
+  },
+
+  // ============================================================================
+  // Date & Time
+  // ============================================================================
+  {
+    id: 'date-current',
+    name: 'Current Date/Time',
+    category: 'date-time',
+    description: 'Get current date and time values',
+    sql: `SELECT
+  NOW() AS now,
+  CURRENT_TIMESTAMP AS current_timestamp,
+  CURRENT_DATE AS today,
+  CURRENT_TIME AS current_time,
+  LOCALTIME AS local_time,
+  LOCALTIMESTAMP AS local_timestamp;`,
+    difficulty: 'beginner',
+    tags: ['date', 'time', 'now', 'current'],
+  },
+  {
+    id: 'date-extract',
+    name: 'Extract Date Parts',
+    category: 'date-time',
+    description: 'Get year, month, day, etc. from dates',
+    sql: `SELECT
+  created_at,
+  EXTRACT(YEAR FROM created_at) AS year,
+  EXTRACT(MONTH FROM created_at) AS month,
+  EXTRACT(DAY FROM created_at) AS day,
+  EXTRACT(DOW FROM created_at) AS day_of_week,
+  EXTRACT(HOUR FROM created_at) AS hour
+FROM users;`,
+    difficulty: 'beginner',
+    requiresSampleData: true,
+    tags: ['date', 'extract', 'year', 'month', 'day'],
+  },
+  {
+    id: 'date-interval',
+    name: 'Date Arithmetic',
+    category: 'date-time',
+    description: 'Add and subtract time intervals',
+    sql: `SELECT
+  NOW() AS now,
+  NOW() + INTERVAL '1 day' AS tomorrow,
+  NOW() - INTERVAL '1 week' AS last_week,
+  NOW() + INTERVAL '3 months' AS in_3_months,
+  NOW() - INTERVAL '1 year' AS last_year,
+  AGE(NOW(), '2020-01-01'::timestamp) AS time_since_2020;`,
+    difficulty: 'intermediate',
+    tags: ['date', 'interval', 'arithmetic', 'add', 'subtract'],
+  },
+  {
+    id: 'date-format',
+    name: 'Format Dates',
+    category: 'date-time',
+    description: 'Convert dates to formatted strings',
+    sql: `SELECT
+  created_at,
+  TO_CHAR(created_at, 'YYYY-MM-DD') AS iso_date,
+  TO_CHAR(created_at, 'Month DD, YYYY') AS full_date,
+  TO_CHAR(created_at, 'Day') AS day_name,
+  TO_CHAR(created_at, 'HH24:MI:SS') AS time_24h,
+  TO_CHAR(created_at, 'HH:MI AM') AS time_12h
+FROM users;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['date', 'format', 'to_char'],
+  },
+  {
+    id: 'date-truncate',
+    name: 'Truncate Dates',
+    category: 'date-time',
+    description: 'Round dates to specific precision',
+    sql: `SELECT
+  created_at,
+  DATE_TRUNC('year', created_at) AS year_start,
+  DATE_TRUNC('month', created_at) AS month_start,
+  DATE_TRUNC('week', created_at) AS week_start,
+  DATE_TRUNC('day', created_at) AS day_start,
+  DATE_TRUNC('hour', created_at) AS hour_start
+FROM users;`,
+    difficulty: 'intermediate',
+    requiresSampleData: true,
+    tags: ['date', 'truncate', 'round'],
+  },
+
+  // ============================================================================
+  // Advanced
+  // ============================================================================
+  {
+    id: 'adv-generate-series',
+    name: 'Generate Series',
+    category: 'advanced',
+    description: 'Generate sequences of numbers or dates',
+    sql: `-- Number sequence
+SELECT generate_series(1, 10) AS num;
+
+-- Date sequence (one row per day)
+SELECT generate_series(
+  '2024-01-01'::date,
+  '2024-01-07'::date,
+  '1 day'::interval
+)::date AS date;
+
+-- Time slots (hourly)
+SELECT generate_series(
+  '2024-01-01 09:00'::timestamp,
+  '2024-01-01 17:00'::timestamp,
+  '1 hour'::interval
+) AS time_slot;`,
+    difficulty: 'intermediate',
+    tags: ['generate_series', 'sequence', 'numbers', 'dates'],
+  },
+  {
+    id: 'adv-recursive-cte',
+    name: 'Recursive CTE',
+    category: 'advanced',
+    description: 'Create hierarchical or iterative queries',
+    sql: `-- Fibonacci sequence
+WITH RECURSIVE fib(n, a, b) AS (
+  SELECT 1, 0::bigint, 1::bigint
+  UNION ALL
+  SELECT n + 1, b, a + b
+  FROM fib
+  WHERE n < 20
+)
+SELECT n, a AS fibonacci
+FROM fib;
+
+-- Number sequence (alternative to generate_series)
+WITH RECURSIVE nums(n) AS (
+  SELECT 1
+  UNION ALL
+  SELECT n + 1 FROM nums WHERE n < 10
+)
+SELECT * FROM nums;`,
+    difficulty: 'advanced',
+    tags: ['recursive', 'cte', 'hierarchy', 'iteration'],
+  },
+  {
+    id: 'adv-lateral-join',
+    name: 'LATERAL Join',
+    category: 'advanced',
+    description: 'Reference outer query in subquery',
+    sql: `-- Get top 2 posts per user
+SELECT
+  u.name,
+  top_posts.title,
+  top_posts.created_at
+FROM users u
+CROSS JOIN LATERAL (
+  SELECT title, created_at
+  FROM posts p
+  WHERE p.user_id = u.id
+  ORDER BY created_at DESC
+  LIMIT 2
+) AS top_posts;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['lateral', 'join', 'correlated', 'top-n'],
+  },
+  {
+    id: 'adv-array-agg',
+    name: 'Array Aggregation',
+    category: 'advanced',
+    description: 'Combine values into arrays',
+    sql: `SELECT
+  u.name,
+  ARRAY_AGG(p.title ORDER BY p.created_at) AS post_titles,
+  STRING_AGG(p.title, ', ' ORDER BY p.created_at) AS titles_csv
+FROM users u
+LEFT JOIN posts p ON p.user_id = u.id
+GROUP BY u.id, u.name
+ORDER BY u.name;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['array_agg', 'string_agg', 'aggregate', 'array'],
+  },
+  {
+    id: 'adv-explain-analyze',
+    name: 'EXPLAIN ANALYZE',
+    category: 'advanced',
+    description: 'Analyze query execution plan',
+    sql: `EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
+SELECT u.name, COUNT(p.id) AS post_count
+FROM users u
+LEFT JOIN posts p ON p.user_id = u.id
+GROUP BY u.id, u.name
+ORDER BY post_count DESC;`,
+    difficulty: 'advanced',
+    requiresSampleData: true,
+    tags: ['explain', 'analyze', 'performance', 'plan'],
+  },
+]
+
+/**
+ * Get sample queries by category
+ */
+export function getQueriesByCategory(category: SampleQueryCategory): SampleQuery[] {
+  return SAMPLE_QUERIES.filter((q) => q.category === category)
+}
+
+/**
+ * Get sample queries by difficulty
+ */
+export function getQueriesByDifficulty(
+  difficulty: 'beginner' | 'intermediate' | 'advanced'
+): SampleQuery[] {
+  return SAMPLE_QUERIES.filter((q) => q.difficulty === difficulty)
+}
+
+/**
+ * Get sample queries that don't require sample data
+ */
+export function getStandaloneQueries(): SampleQuery[] {
+  return SAMPLE_QUERIES.filter((q) => !q.requiresSampleData)
+}
+
+/**
+ * Search sample queries by keyword
+ */
+export function searchQueries(keyword: string): SampleQuery[] {
+  const lower = keyword.toLowerCase()
+  return SAMPLE_QUERIES.filter(
+    (q) =>
+      q.name.toLowerCase().includes(lower) ||
+      q.description.toLowerCase().includes(lower) ||
+      q.sql.toLowerCase().includes(lower) ||
+      q.tags?.some((t) => t.toLowerCase().includes(lower))
+  )
+}
+
+/**
+ * Get a sample query by ID
+ */
+export function getQueryById(id: string): SampleQuery | undefined {
+  return SAMPLE_QUERIES.find((q) => q.id === id)
+}