database-model-generator 0.6.0 → 0.7.0

data/docker/postgresql/POSTGRESQL.md

@@ -0,0 +1,278 @@
+# PostgreSQL Support
+
+This document describes the PostgreSQL implementation for the database-model-generator library.
+
+## Overview
+
+PostgreSQL support has been added to the database-model-generator library, allowing you to generate ActiveRecord models from existing PostgreSQL tables and views. The implementation follows the same architecture as Oracle and SQL Server support.
+
+## Features
+
+The PostgreSQL generator includes:
+
+- **Full table introspection** via PostgreSQL's `information_schema`
+- **Primary key detection** using `pg_index` and `pg_attribute`
+- **Foreign key detection** with automatic relationship inference
+- **Constraint detection** including CHECK, UNIQUE, and NOT NULL constraints
+- **Enum detection** from CHECK constraints with IN clauses
+- **Polymorphic association detection** (e.g., commentable_id + commentable_type)
+- **Index recommendations** for foreign keys, dates, text search, and composite indexes
+- **Full-text search support** using PostgreSQL's GIN indexes and tsvector
+- **Dependency tracking** for views and related objects
+
+## Installation
+
+Add the `pg` gem to your Gemfile or install it directly:
+
+```bash
+gem install pg
+```
+
+## Usage
+
+### With the Command Line Tool
+
+```bash
+# Using explicit database type
+dmg -T postgresql -h localhost -d your_database -t users -u postgres [-p password]
+
+# Using auto-detection (if connection parameters indicate PostgreSQL)
+dmg -h localhost -d your_database -t users -u postgres [-p password]
+
+# Password is optional if pg_hba.conf is configured for trust authentication
+dmg -T postgresql -h localhost -d your_database -t users -u postgres
+```
+
+### Programmatically
+
+```ruby
+require 'pg'
+require 'database_model_generator'
+
+# Connect to PostgreSQL
+# Note: password is optional if pg_hba.conf allows trust authentication
+conn = PG.connect(
+  host: 'localhost',
+  port: 5432,
+  dbname: 'your_database',
+  user: 'postgres'
+  # password: 'your_password'  # Only needed if authentication is required
+)
+
+# Create a generator instance
+generator = DatabaseModel::Generator.new(conn)
+
+# Generate model information
+generator.generate('users')
+
+# Access model information
+puts "Model name: #{generator.model}"
+puts "Table name: #{generator.table}"
+puts "Columns: #{generator.column_names.join(', ')}"
+puts "Primary keys: #{generator.primary_keys.join(', ')}"
+puts "Foreign keys: #{generator.foreign_keys.join(', ')}"
+
+# Get enum columns
+if generator.has_enum_columns?
+  puts "\nEnum columns detected:"
+  generator.enum_columns.each do |enum_col|
+    puts "  #{enum_col[:name]}: #{enum_col[:values].join(', ')}"
+  end
+end
+
+# Get polymorphic associations
+if generator.has_polymorphic_associations?
+  puts "\nPolymorphic associations:"
+  generator.polymorphic_associations.each do |assoc|
+    puts "  #{assoc[:name]} (#{assoc[:foreign_key]}, #{assoc[:foreign_type]})"
+  end
+end
+
+# Get index recommendations
+recommendations = generator.index_recommendations
+puts "\nIndex recommendations:"
+recommendations[:foreign_keys].each do |rec|
+  puts "  #{rec[:sql]}"
+end
+
+# Close connection
+generator.disconnect
+```
+
+## PostgreSQL-Specific Features
+
+### Full-Text Search
+
+PostgreSQL's powerful full-text search is supported through GIN indexes:
+
+```ruby
+generator.generate('posts')
+recommendations = generator.index_recommendations
+
+# Full-text recommendations use to_tsvector
+recommendations[:full_text].each do |rec|
+  puts rec[:sql]
+  # CREATE INDEX idx_posts_content_text ON posts
+  #   USING GIN (to_tsvector('english', content))
+end
+```
+
+### Enum Detection from CHECK Constraints
+
+PostgreSQL CHECK constraints are parsed to detect enum columns:
+
+```sql
+CREATE TABLE users (
+  status VARCHAR(20) DEFAULT 'active',
+  CONSTRAINT check_status CHECK (status IN ('active', 'inactive', 'suspended'))
+);
+```
+
+```ruby
+generator.generate('users')
+generator.enum_columns
+# => [{name: 'status', values: ['active', 'inactive', 'suspended'], ...}]
+```
+
+### Data Type Support
+
+The PostgreSQL generator handles all standard PostgreSQL data types:
+
+- **Character types**: CHAR, VARCHAR, TEXT, CHARACTER VARYING
+- **Numeric types**: INTEGER, BIGINT, DECIMAL, NUMERIC, REAL, DOUBLE PRECISION
+- **Date/Time types**: DATE, TIME, TIMESTAMP, TIMESTAMPTZ, INTERVAL
+- **Boolean type**: BOOLEAN
+- **Binary types**: BYTEA
+- **JSON types**: JSON, JSONB
+- **Arrays and custom types**: Detected via `udt_name` column
+
+## Testing
+
+### Using Docker
+
+The easiest way to test PostgreSQL support is using the provided Docker setup:
+
+```bash
+cd docker/postgresql
+
+# Start PostgreSQL
+docker-compose up -d postgres-db
+
+# Wait for it to be healthy
+docker-compose ps
+
+# Run tests
+docker-compose run --rm dmg_test
+```
+
+### Manual Testing
+
+If you have PostgreSQL installed locally:
+
+```bash
+# Create test database
+createdb test_db
+
+# Run initialization script
+psql -d test_db -f docker/postgresql/init-db.sql
+
+# Run tests
+bundle exec rspec spec/postgresql_model_generator_spec.rb
+```
+
+## Database Schema Example
+
+The test database includes:
+
+- **users** - with status and role enum columns
+- **posts** - with foreign key to users, status and priority enums
+- **comments** - with polymorphic association (commentable)
+- **tags** - simple lookup table
+- **post_tags** - many-to-many join table with composite primary key
+
+## Architecture
+
+The PostgreSQL generator is implemented in `lib/postgresql/model/generator.rb` and extends the `DatabaseModel::Generator::Base` class, providing PostgreSQL-specific implementations for:
+
+- `validate_connection` - ensures connection is a `PG::Connection`
+- `normalize_table_name` - converts to lowercase (PostgreSQL convention)
+- `check_table_exists` - queries `information_schema.tables`
+- `get_column_info` - retrieves column metadata
+- `get_primary_keys` - queries `pg_index` system catalog
+- `get_foreign_keys` - queries `information_schema.table_constraints`
+- `get_constraints` - retrieves all constraint information
+- `get_dependencies` - finds dependent views and objects
+- Type checking methods for PostgreSQL data types
+
+## Comparison with Other Databases
+
+| Feature | Oracle | SQL Server | PostgreSQL |
+|---------|--------|------------|------------|
+| Connection | OCI8 | TinyTds::Client | PG::Connection |
+| Schema queries | USER_* views | INFORMATION_SCHEMA | INFORMATION_SCHEMA + pg_* |
+| Table name case | UPPERCASE | Case-sensitive | lowercase |
+| Full-text search | Oracle Text | FULLTEXT INDEX | GIN + tsvector |
+| Enum detection | ✓ | ✓ | ✓ |
+| Polymorphic | ✓ | ✓ | ✓ |
+| Composite PKs | ✓ | ✓ | ✓ |
+
+## Troubleshooting
+
+### Connection Issues
+
+If you get connection errors:
+
+```ruby
+PG::ConnectionBad: could not connect to server
+```
+
+Check:
+1. PostgreSQL is running: `pg_isready`
+2. Connection parameters are correct
+3. User has proper permissions
+4. `pg_hba.conf` allows the connection
+
+### Missing Tables
+
+If tables aren't found:
+
+```ruby
+generator.table_exists? # => false
+```
+
+Check:
+1. Table is in the `public` schema (or adjust schema in queries)
+2. User has SELECT permission on the table
+3. Table name is correct (case-sensitive in PostgreSQL when quoted)
+
+### Gem Installation Issues
+
+On macOS with Homebrew PostgreSQL:
+
+```bash
+gem install pg -- --with-pg-config=/usr/local/bin/pg_config
+```
+
+Or with a specific PostgreSQL version:
+
+```bash
+gem install pg -- --with-pg-config=/usr/local/opt/postgresql@14/bin/pg_config
+```
+
+## Future Enhancements
+
+Possible future improvements:
+
+- Support for PostgreSQL-specific features (arrays, JSON columns)
+- Custom type (enum, composite) detection
+- Partitioned table support
+- Foreign data wrapper detection
+- Materialized view support
+- PostgreSQL extension detection (PostGIS, etc.)
+
+## References
+
+- [PostgreSQL Documentation](https://www.postgresql.org/docs/)
+- [pg gem documentation](https://github.com/ged/ruby-pg)
+- [PostgreSQL INFORMATION_SCHEMA](https://www.postgresql.org/docs/current/information-schema.html)
+- [PostgreSQL System Catalogs](https://www.postgresql.org/docs/current/catalogs.html)

data/docker/postgresql/README.md

@@ -0,0 +1,116 @@
+# PostgreSQL Docker Setup for Database Model Generator
+
+This directory contains Docker setup files for testing the PostgreSQL model generator.
+
+## Prerequisites
+
+- Docker
+- Docker Compose
+
+## Quick Start
+
+1. Start the PostgreSQL container:
+
+```bash
+cd docker/postgresql
+docker-compose up -d postgres-db
+```
+
+2. Wait for PostgreSQL to be ready (check with):
+
+```bash
+docker-compose logs -f postgres-db
+```
+
+3. Run the tests:
+
+```bash
+docker-compose run --rm dmg_test
+```
+
+Or run tests directly:
+
+```bash
+docker-compose run --rm dmg_test bundle exec rspec spec/postgresql_model_generator_spec.rb
+```
+
+## Environment Variables
+
+The following environment variables are available:
+
+- `POSTGRES_HOST`: PostgreSQL host (default: postgres-db)
+- `POSTGRES_PORT`: PostgreSQL port (default: 5432)
+- `POSTGRES_USER`: PostgreSQL username (default: postgres)
+- `POSTGRES_PASSWORD`: PostgreSQL password (optional, omit if using trust authentication)
+- `POSTGRES_DATABASE`: PostgreSQL database name (default: test_db)
+
+## Sample Database
+
+The `init-db.sql` file creates a sample database schema with:
+
+- **users** table - with status and role enum columns
+- **posts** table - with foreign key to users, status and priority enums
+- **comments** table - with polymorphic association (commentable)
+- **tags** table - simple lookup table
+- **post_tags** table - many-to-many join table
+
+This schema is designed to test various features of the model generator including:
+- Foreign key detection
+- Enum column detection
+- Polymorphic associations
+- Primary keys
+- Constraints
+- Indexes
+- Full-text search recommendations
+
+## Manual Testing
+
+To connect to PostgreSQL manually:
+
+```bash
+docker-compose exec postgres-db psql -U postgres -d test_db
+```
+
+## Stopping and Cleaning Up
+
+Stop the containers:
+
+```bash
+docker-compose down
+```
+
+Stop and remove volumes (warning: this deletes all data):
+
+```bash
+docker-compose down -v
+```
+
+## Troubleshooting
+
+### PostgreSQL won't start
+
+Check the logs:
+
+```bash
+docker-compose logs postgres-db
+```
+
+### Connection refused
+
+Make sure the healthcheck passes:
+
+```bash
+docker-compose ps
+```
+
+The postgres-db service should show as "healthy".
+
+### Tests fail
+
+Ensure the database is initialized properly:
+
+```bash
+docker-compose exec postgres-db psql -U postgres -d test_db -c "\dt"
+```
+
+You should see the tables listed.

data/docker/postgresql/docker-compose.yml

@@ -0,0 +1,51 @@
+services:
+  # PostgreSQL database for testing
+  postgres-db:
+    image: postgres:16-alpine
+    container_name: dmg_postgres
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=test_db
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./init-db.sql:/docker-entrypoint-initdb.d/init-db.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+    networks:
+      - dmg_network
+
+  # Optional: Add a container to test the generator
+  dmg_test:
+    build:
+      context: ../../
+      dockerfile: docker/postgresql/test-Dockerfile
+    container_name: dmg_test_runner
+    depends_on:
+      postgres-db:
+        condition: service_healthy
+    volumes:
+      - ../../:/app
+    working_dir: /app
+    environment:
+      - POSTGRES_HOST=postgres-db
+      - POSTGRES_PORT=5432
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DATABASE=test_db
+    networks:
+      - dmg_network
+    command: ["./docker/postgresql/test.sh"]
+
+volumes:
+  postgres_data:
+
+networks:
+  dmg_network:
+    driver: bridge

data/docker/postgresql/init-db.sql

@@ -0,0 +1,101 @@
+-- PostgreSQL test database initialization script
+-- Create sample tables for testing the model generator
+
+-- Create users table
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    username VARCHAR(50) NOT NULL UNIQUE,
+    email VARCHAR(100) NOT NULL UNIQUE,
+    first_name VARCHAR(50),
+    last_name VARCHAR(50),
+    status VARCHAR(20) DEFAULT 'active',
+    role VARCHAR(20) DEFAULT 'user',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT check_status CHECK (status IN ('active', 'inactive', 'suspended', 'deleted')),
+    CONSTRAINT check_role CHECK (role IN ('user', 'admin', 'moderator'))
+);
+
+-- Create posts table
+CREATE TABLE posts (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL,
+    title VARCHAR(200) NOT NULL,
+    content TEXT,
+    status VARCHAR(20) DEFAULT 'draft',
+    priority VARCHAR(10) DEFAULT 'medium',
+    published_at TIMESTAMP,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT fk_posts_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT check_post_status CHECK (status IN ('draft', 'published', 'archived')),
+    CONSTRAINT check_priority CHECK (priority IN ('low', 'medium', 'high', 'urgent'))
+);
+
+-- Create comments table (with polymorphic association)
+CREATE TABLE comments (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL,
+    commentable_id INTEGER NOT NULL,
+    commentable_type VARCHAR(50) NOT NULL,
+    content TEXT NOT NULL,
+    status VARCHAR(20) DEFAULT 'active',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT fk_comments_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT check_comment_status CHECK (status IN ('active', 'hidden', 'deleted'))
+);
+
+-- Create tags table
+CREATE TABLE tags (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(50) NOT NULL UNIQUE,
+    slug VARCHAR(60) NOT NULL UNIQUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create post_tags (join table)
+CREATE TABLE post_tags (
+    post_id INTEGER NOT NULL,
+    tag_id INTEGER NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (post_id, tag_id),
+    CONSTRAINT fk_post_tags_post FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
+    CONSTRAINT fk_post_tags_tag FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
+);
+
+-- Create indexes for better query performance
+CREATE INDEX idx_posts_user_id ON posts(user_id);
+CREATE INDEX idx_posts_status ON posts(status);
+CREATE INDEX idx_posts_created_at ON posts(created_at);
+CREATE INDEX idx_comments_user_id ON comments(user_id);
+CREATE INDEX idx_comments_commentable ON comments(commentable_id, commentable_type);
+
+-- Create a full-text search index
+CREATE INDEX idx_posts_title_content_text ON posts USING GIN (to_tsvector('english', title || ' ' || COALESCE(content, '')));
+
+-- Insert sample data
+INSERT INTO users (username, email, first_name, last_name, status, role) VALUES
+    ('john_doe', 'john@example.com', 'John', 'Doe', 'active', 'admin'),
+    ('jane_smith', 'jane@example.com', 'Jane', 'Smith', 'active', 'user'),
+    ('bob_jones', 'bob@example.com', 'Bob', 'Jones', 'inactive', 'moderator');
+
+INSERT INTO posts (user_id, title, content, status, priority) VALUES
+    (1, 'First Post', 'This is the content of the first post', 'published', 'high'),
+    (1, 'Second Post', 'This is the content of the second post', 'draft', 'medium'),
+    (2, 'Jane''s Post', 'Jane writes about something interesting', 'published', 'low');
+
+INSERT INTO tags (name, slug) VALUES
+    ('Technology', 'technology'),
+    ('Ruby', 'ruby'),
+    ('PostgreSQL', 'postgresql');
+
+INSERT INTO post_tags (post_id, tag_id) VALUES
+    (1, 1),
+    (1, 2),
+    (3, 1),
+    (3, 3);
+
+INSERT INTO comments (user_id, commentable_id, commentable_type, content) VALUES
+    (2, 1, 'Post', 'Great post!'),
+    (3, 1, 'Post', 'Thanks for sharing');

data/docker/postgresql/test-Dockerfile

@@ -0,0 +1,20 @@
+FROM ruby:3.2-alpine
+
+# Install build dependencies
+RUN apk add --no-cache \
+    build-base \
+    postgresql-dev \
+    postgresql-client \
+    git
+
+# Set working directory
+WORKDIR /app
+
+# Copy application files
+COPY . .
+
+# Install dependencies
+RUN bundle install
+
+# Run tests
+CMD ["bundle", "exec", "rspec", "spec/postgresql_model_generator_spec.rb"]

data/docker/postgresql/test.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+echo "Waiting for PostgreSQL to be ready..."
+until pg_isready -h $POSTGRES_HOST -p $POSTGRES_PORT -U $POSTGRES_USER; do
+  echo "PostgreSQL is unavailable - sleeping"
+  sleep 2
+done
+
+echo "PostgreSQL is up - running tests"
+
+# Install dependencies if needed
+bundle check || bundle install
+
+# Run the tests
+bundle exec rspec spec/postgresql_model_generator_spec.rb -fd
+
+echo "Tests completed!"

data/lib/database_model_generator.rb

@@ -10,10 +10,16 @@ rescue LoadError
   # TinyTDS not available - SQL Server support will be disabled
 end
 
+begin
+  require 'pg'
+rescue LoadError
+  # pg not available - PostgreSQL support will be disabled
+end
+
 module DatabaseModel
   module Generator
     # The version of the database-model-generator library
-    VERSION = '0.6.0'
+    VERSION = '0.7.0'
 
     # Factory method to create the appropriate generator based on connection type
     def self.new(connection, options = {})
@@ -26,6 +32,9 @@ module DatabaseModel
       when :sqlserver
         require_relative 'sqlserver/model/generator'
         SqlServer::Model::Generator.new(connection)
+      when :postgresql
+        require_relative 'postgresql/model/generator'
+        Postgresql::Model::Generator.new(connection)
       else
         raise ArgumentError, "Unsupported database type: #{database_type}"
       end
@@ -41,6 +50,8 @@ module DatabaseModel
         :oracle
       when 'TinyTds::Client'
         :sqlserver
+      when 'PG::Connection'
+        :postgresql
       else
         raise ArgumentError, "Cannot detect database type from connection: #{connection.class}"
       end