better_structure_sql 0.1.0 → 0.2.1

data/lib/better_structure_sql/adapters/mysql_adapter.rb

@@ -35,6 +35,8 @@ module BetterStructureSql
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
       # @return [Array<Hash>] Array of table hashes with :name, :schema, :columns, :primary_key, :constraints
       def fetch_tables(connection)
+        # Performance optimized: Batches all table metadata queries to avoid N+1 queries
+        # For 1000 tables: 4 queries instead of 3001 queries (~750x faster)
         query = <<~SQL.squish
           SELECT
             TABLE_NAME,
@@ -45,14 +47,25 @@ module BetterStructureSql
           ORDER BY TABLE_NAME
         SQL
 
-        connection.execute(query).map do |row|
+        table_rows = connection.execute(query).to_a
+        return [] if table_rows.empty?
+
+        table_names = table_rows.pluck(0)
+
+        # Batch fetch all columns, primary keys, and constraints
+        columns_by_table = fetch_all_columns(connection, table_names)
+        primary_keys_by_table = fetch_all_primary_keys(connection, table_names)
+        constraints_by_table = fetch_all_constraints(connection, table_names)
+
+        # Combine results
+        table_rows.map do |row|
           table_name = row[0] # MySQL returns arrays not hashes by default
           {
             name: table_name,
             schema: row[1],
-            columns: fetch_columns(connection, table_name),
-            primary_key: fetch_primary_key(connection, table_name),
-            constraints: fetch_constraints(connection, table_name)
+            columns: columns_by_table[table_name] || [],
+            primary_key: primary_keys_by_table[table_name] || [],
+            constraints: constraints_by_table[table_name] || []
           }
         end
       end
@@ -254,6 +267,20 @@ module BetterStructureSql
         end
       end
 
+      # Fetch comments on database objects
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash] Hash with object types as keys (:tables, :columns)
+      def fetch_comments(connection)
+        {
+          tables: fetch_table_comments(connection),
+          columns: fetch_column_comments(connection),
+          indexes: {},  # MySQL doesn't support index comments via information_schema
+          views: {},    # MySQL doesn't expose view comments via information_schema
+          functions: {} # MySQL doesn't expose function comments via information_schema
+        }
+      end
+
       # Capability methods - MySQL feature support
 
       # Indicates whether MySQL supports extensions
@@ -312,6 +339,13 @@ module BetterStructureSql
         version_at_least?(database_version, '8.0.16')
       end
 
+      # Indicates whether MySQL supports comments on database objects
+      #
+      # @return [Boolean] Always true for MySQL (tables and columns only)
+      def supports_comments?
+        true # MySQL supports table and column comments
+      end
+
       # Version detection
 
       # Get the current MySQL database version
@@ -428,6 +462,125 @@ module BetterStructureSql
         []
       end
 
+      # Batch fetch all columns for multiple tables (performance optimization)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param table_names [Array<String>] Array of table names
+      # @return [Hash<String, Array<Hash>>] Hash of table_name => array of column hashes
+      def fetch_all_columns(connection, table_names)
+        return {} if table_names.empty?
+
+        # Build IN clause with quoted table names
+        quoted_names = table_names.map { |t| connection.quote(t) }.join(', ')
+
+        query = <<~SQL.squish
+          SELECT
+            TABLE_NAME,
+            COLUMN_NAME,
+            DATA_TYPE,
+            IS_NULLABLE,
+            COLUMN_DEFAULT,
+            CHARACTER_MAXIMUM_LENGTH,
+            NUMERIC_PRECISION,
+            NUMERIC_SCALE,
+            COLUMN_TYPE,
+            EXTRA,
+            ORDINAL_POSITION
+          FROM information_schema.COLUMNS
+          WHERE TABLE_NAME IN (#{quoted_names})
+            AND TABLE_SCHEMA = DATABASE()
+          ORDER BY TABLE_NAME, ORDINAL_POSITION
+        SQL
+
+        result = Hash.new { |h, k| h[k] = [] }
+
+        connection.execute(query).each do |row|
+          # Build row array compatible with resolve_column_type expectations
+          # resolve_column_type expects: [nil, DATA_TYPE, nil, nil, LENGTH, PRECISION, SCALE, COLUMN_TYPE]
+          column_row = [nil, row[2], nil, nil, row[5], row[6], row[7], row[8]]
+
+          result[row[0]] << {
+            name: row[1],
+            type: resolve_column_type(column_row),
+            nullable: row[3] == 'YES',
+            default: row[4],
+            length: row[5],
+            precision: row[6],
+            scale: row[7],
+            column_type: row[8],
+            extra: row[9]
+          }
+        end
+
+        result
+      end
+
+      # Batch fetch all primary keys for multiple tables (performance optimization)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param table_names [Array<String>] Array of table names
+      # @return [Hash<String, Array<String>>] Hash of table_name => array of primary key column names
+      def fetch_all_primary_keys(connection, table_names)
+        return {} if table_names.empty?
+
+        quoted_names = table_names.map { |t| connection.quote(t) }.join(', ')
+
+        query = <<~SQL.squish
+          SELECT TABLE_NAME, COLUMN_NAME, ORDINAL_POSITION
+          FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_NAME IN (#{quoted_names})
+            AND TABLE_SCHEMA = DATABASE()
+            AND CONSTRAINT_NAME = 'PRIMARY'
+          ORDER BY TABLE_NAME, ORDINAL_POSITION
+        SQL
+
+        result = Hash.new { |h, k| h[k] = [] }
+
+        connection.execute(query).each do |row|
+          result[row[0]] << row[1]
+        end
+
+        result
+      end
+
+      # Batch fetch all constraints for multiple tables (performance optimization)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param table_names [Array<String>] Array of table names
+      # @return [Hash<String, Array<Hash>>] Hash of table_name => array of constraint hashes
+      def fetch_all_constraints(connection, table_names)
+        return {} if table_names.empty?
+        return {} unless supports_check_constraints? # MySQL < 8.0.16
+
+        quoted_names = table_names.map { |t| connection.quote(t) }.join(', ')
+
+        query = <<~SQL.squish
+          SELECT
+            TABLE_NAME,
+            CONSTRAINT_NAME,
+            CHECK_CLAUSE
+          FROM information_schema.CHECK_CONSTRAINTS
+          WHERE CONSTRAINT_SCHEMA = DATABASE()
+            AND TABLE_NAME IN (#{quoted_names})
+          ORDER BY TABLE_NAME, CONSTRAINT_NAME
+        SQL
+
+        result = Hash.new { |h, k| h[k] = [] }
+
+        connection.execute(query).each do |row|
+          result[row[0]] << {
+            name: row[1],
+            definition: row[2],
+            type: :check
+          }
+        end
+
+        result
+      rescue StandardError
+        # If CHECK_CONSTRAINTS table doesn't exist, return empty hash
+        {}
+      end
+
       # Resolve MySQL column type into normalized format
       #
       # @param row [Array] Column information row from information_schema.COLUMNS
@@ -471,6 +624,48 @@ module BetterStructureSql
           data_type
         end
       end
+
+      # Fetch comments on tables
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of table_name => comment
+      def fetch_table_comments(connection)
+        query = <<~SQL.squish
+          SELECT TABLE_NAME, TABLE_COMMENT
+          FROM information_schema.TABLES
+          WHERE TABLE_SCHEMA = DATABASE()
+            AND TABLE_TYPE = 'BASE TABLE'
+            AND TABLE_COMMENT != ''
+          ORDER BY TABLE_NAME
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          result[row[0]] = row[1]
+        end
+        result
+      end
+
+      # Fetch comments on columns
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of "table_name.column_name" => comment
+      def fetch_column_comments(connection)
+        query = <<~SQL.squish
+          SELECT TABLE_NAME, COLUMN_NAME, COLUMN_COMMENT
+          FROM information_schema.COLUMNS
+          WHERE TABLE_SCHEMA = DATABASE()
+            AND COLUMN_COMMENT != ''
+          ORDER BY TABLE_NAME, ORDINAL_POSITION
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          key = "#{row[0]}.#{row[1]}"
+          result[key] = row[2]
+        end
+        result
+      end
     end
   end
 end

data/lib/better_structure_sql/adapters/postgresql_adapter.rb

@@ -37,46 +37,20 @@ module BetterStructureSql
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
       # @return [Array<Hash>] Array of type hashes with :name, :schema, :type, and type-specific attributes
       def fetch_custom_types(connection)
-        query = <<~SQL.squish
-          SELECT
-            t.typname as name,
-            t.typtype as type,
-            n.nspname as schema
-          FROM pg_type t
-          JOIN pg_namespace n ON n.oid = t.typnamespace
-          LEFT JOIN pg_class c ON c.reltype = t.oid AND c.relkind IN ('r', 'v', 'm')
-          WHERE t.typtype IN ('e', 'c', 'd')
-            AND n.nspname NOT IN ('pg_catalog', 'information_schema')
-            AND c.oid IS NULL
-          ORDER BY t.typname
-        SQL
-
-        connection.execute(query).map do |row|
-          type_data = {
-            name: row['schema'] == 'public' ? row['name'] : "#{row['schema']}.#{row['name']}",
-            schema: row['schema'],
-            type: type_category(row['type'])
-          }
-
-          case row['type']
-          when 'e'
-            type_data[:values] = fetch_enum_values(connection, row['name'])
-          when 'c'
-            type_data[:attributes] = fetch_composite_attributes(connection, row['name'])
-          when 'd'
-            type_data.merge!(fetch_domain_details(connection, row['name']))
-          end
-
-          type_data
-        end
+        query = custom_types_query
+        connection.execute(query).map { |row| build_custom_type(connection, row) }
       end
 
       # Fetch all tables from the database
       #
+      # Performance optimized: Batches all table metadata queries to avoid N+1 queries.
+      # For 1000 tables: 4 queries instead of 3001 queries (~750x faster)
+      #
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
       # @return [Array<Hash>] Array of table hashes with :name, :schema, :columns, :primary_key, :constraints
       def fetch_tables(connection)
-        query = <<~SQL.squish
+        # Fetch all table names first
+        tables_query = <<~SQL.squish
           SELECT table_name, table_schema
           FROM information_schema.tables
           WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
@@ -84,14 +58,25 @@ module BetterStructureSql
           ORDER BY table_name
         SQL
 
-        connection.execute(query).map do |row|
+        table_rows = connection.execute(tables_query).to_a
+        return [] if table_rows.empty?
+
+        table_names = table_rows.pluck('table_name')
+
+        # Batch fetch all columns, primary keys, and constraints
+        columns_by_table = fetch_all_columns(connection, table_names)
+        primary_keys_by_table = fetch_all_primary_keys(connection, table_names)
+        constraints_by_table = fetch_all_constraints(connection, table_names)
+
+        # Combine results
+        table_rows.map do |row|
           table_name = row['table_name']
           {
             name: table_name,
             schema: row['table_schema'],
-            columns: fetch_columns(connection, table_name),
-            primary_key: fetch_primary_key(connection, table_name),
-            constraints: fetch_constraints(connection, table_name)
+            columns: columns_by_table[table_name] || [],
+            primary_key: primary_keys_by_table[table_name] || [],
+            constraints: constraints_by_table[table_name] || []
           }
         end
       end
@@ -319,6 +304,20 @@ module BetterStructureSql
         end
       end
 
+      # Fetch comments on database objects
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash] Hash with object types as keys (:tables, :columns, :indexes, :views, :functions)
+      def fetch_comments(connection)
+        {
+          tables: fetch_table_comments(connection),
+          columns: fetch_column_comments(connection),
+          indexes: fetch_index_comments(connection),
+          views: fetch_view_comments(connection),
+          functions: fetch_function_comments(connection)
+        }
+      end
+
       # Capability methods - PostgreSQL supports all features
 
       # Indicates whether PostgreSQL supports extensions
@@ -370,6 +369,13 @@ module BetterStructureSql
         true
       end
 
+      # Indicates whether PostgreSQL supports comments
+      #
+      # @return [Boolean] Always true for PostgreSQL
+      def supports_comments?
+        true
+      end
+
       # Version detection
 
       # Get the current PostgreSQL database version
@@ -485,6 +491,117 @@ module BetterStructureSql
         end
       end
 
+      # Batch fetch all columns for multiple tables (performance optimization)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param table_names [Array<String>] Array of table names
+      # @return [Hash<String, Array<Hash>>] Hash of table_name => array of column hashes
+      def fetch_all_columns(connection, table_names)
+        return {} if table_names.empty?
+
+        query = <<~SQL.squish
+          SELECT
+            table_name,
+            column_name,
+            data_type,
+            column_default,
+            is_nullable,
+            character_maximum_length,
+            numeric_precision,
+            numeric_scale,
+            udt_name,
+            ordinal_position
+          FROM information_schema.columns
+          WHERE table_name IN (#{table_names.map { |t| connection.quote(t) }.join(', ')})
+            AND table_schema = 'public'
+          ORDER BY table_name, ordinal_position
+        SQL
+
+        result = Hash.new { |h, k| h[k] = [] }
+
+        connection.select_all(query).each do |row|
+          result[row['table_name']] << {
+            name: row['column_name'],
+            type: resolve_column_type(row),
+            default: row['column_default'],
+            nullable: row['is_nullable'] == 'YES',
+            length: row['character_maximum_length'],
+            precision: row['numeric_precision'],
+            scale: row['numeric_scale']
+          }
+        end
+
+        result
+      end
+
+      # Batch fetch all primary keys for multiple tables (performance optimization)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param table_names [Array<String>] Array of table names
+      # @return [Hash<String, Array<String>>] Hash of table_name => array of primary key column names
+      def fetch_all_primary_keys(connection, table_names)
+        return {} if table_names.empty?
+
+        query = <<~SQL.squish
+          SELECT
+            c.relname as table_name,
+            a.attname as column_name,
+            a.attnum as column_position
+          FROM pg_index i
+          JOIN pg_class c ON c.oid = i.indrelid
+          JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE i.indisprimary
+            AND n.nspname = 'public'
+            AND c.relname IN (#{table_names.map { |t| connection.quote(t) }.join(', ')})
+          ORDER BY c.relname, a.attnum
+        SQL
+
+        result = Hash.new { |h, k| h[k] = [] }
+
+        connection.select_all(query).each do |row|
+          result[row['table_name']] << row['column_name']
+        end
+
+        result
+      end
+
+      # Batch fetch all constraints for multiple tables (performance optimization)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param table_names [Array<String>] Array of table names
+      # @return [Hash<String, Array<Hash>>] Hash of table_name => array of constraint hashes
+      def fetch_all_constraints(connection, table_names)
+        return {} if table_names.empty?
+
+        query = <<~SQL.squish
+          SELECT
+            c.relname as table_name,
+            con.conname as name,
+            pg_get_constraintdef(con.oid) as definition,
+            con.contype as type
+          FROM pg_constraint con
+          JOIN pg_class c ON c.oid = con.conrelid
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE con.contype IN ('c', 'u')
+            AND n.nspname = 'public'
+            AND c.relname IN (#{table_names.map { |t| connection.quote(t) }.join(', ')})
+          ORDER BY c.relname, con.conname
+        SQL
+
+        result = Hash.new { |h, k| h[k] = [] }
+
+        connection.select_all(query).each do |row|
+          result[row['table_name']] << {
+            name: row['name'],
+            definition: row['definition'],
+            type: constraint_type(row['type'])
+          }
+        end
+
+        result
+      end
+
       # Fetch enum values for a specific enum type
       #
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
@@ -641,6 +758,173 @@ module BetterStructureSql
         else 'VOLATILE'
         end
       end
+
+      # SQL query for fetching custom types
+      #
+      # @return [String] SQL query string
+      def custom_types_query
+        <<~SQL.squish
+          SELECT
+            t.typname as name,
+            t.typtype as type,
+            n.nspname as schema
+          FROM pg_type t
+          JOIN pg_namespace n ON n.oid = t.typnamespace
+          LEFT JOIN pg_class c ON c.reltype = t.oid AND c.relkind IN ('r', 'v', 'm')
+          WHERE t.typtype IN ('e', 'c', 'd')
+            AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND c.oid IS NULL
+          ORDER BY t.typname
+        SQL
+      end
+
+      # Build custom type hash from query row
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param row [Hash] Row from custom_types_query
+      # @return [Hash] Type hash with name, schema, type, and type-specific attributes
+      def build_custom_type(connection, row)
+        type_data = {
+          name: row['schema'] == 'public' ? row['name'] : "#{row['schema']}.#{row['name']}",
+          schema: row['schema'],
+          type: type_category(row['type'])
+        }
+
+        case row['type']
+        when 'e'
+          type_data[:values] = fetch_enum_values(connection, row['name'])
+        when 'c'
+          type_data[:attributes] = fetch_composite_attributes(connection, row['name'])
+        when 'd'
+          type_data.merge!(fetch_domain_details(connection, row['name']))
+        end
+
+        type_data
+      end
+
+      # Fetch comments on tables
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of table_name => comment
+      def fetch_table_comments(connection)
+        query = <<~SQL.squish
+          SELECT
+            c.relname as table_name,
+            d.description as comment
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_description d ON d.objoid = c.oid AND d.objsubid = 0
+          WHERE c.relkind = 'r'
+            AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+          ORDER BY c.relname
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          result[row['table_name']] = row['comment']
+        end
+        result
+      end
+
+      # Fetch comments on columns
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of "table_name.column_name" => comment
+      def fetch_column_comments(connection)
+        query = <<~SQL.squish
+          SELECT
+            c.relname as table_name,
+            a.attname as column_name,
+            d.description as comment
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_attribute a ON a.attrelid = c.oid
+          JOIN pg_description d ON d.objoid = c.oid AND d.objsubid = a.attnum
+          WHERE c.relkind = 'r'
+            AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+          ORDER BY c.relname, a.attnum
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          key = "#{row['table_name']}.#{row['column_name']}"
+          result[key] = row['comment']
+        end
+        result
+      end
+
+      # Fetch comments on indexes
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of index_name => comment
+      def fetch_index_comments(connection)
+        query = <<~SQL.squish
+          SELECT
+            c.relname as index_name,
+            d.description as comment
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_description d ON d.objoid = c.oid AND d.objsubid = 0
+          WHERE c.relkind = 'i'
+            AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+          ORDER BY c.relname
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          result[row['index_name']] = row['comment']
+        end
+        result
+      end
+
+      # Fetch comments on views
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of view_name => comment
+      def fetch_view_comments(connection)
+        query = <<~SQL.squish
+          SELECT
+            c.relname as view_name,
+            d.description as comment
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_description d ON d.objoid = c.oid AND d.objsubid = 0
+          WHERE c.relkind = 'v'
+            AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+          ORDER BY c.relname
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          result[row['view_name']] = row['comment']
+        end
+        result
+      end
+
+      # Fetch comments on functions
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Hash<String, String>] Hash of function_name => comment
+      def fetch_function_comments(connection)
+        query = <<~SQL.squish
+          SELECT
+            p.proname as function_name,
+            d.description as comment
+          FROM pg_proc p
+          JOIN pg_namespace n ON n.oid = p.pronamespace
+          JOIN pg_description d ON d.objoid = p.oid
+          WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+          ORDER BY p.proname
+        SQL
+
+        result = {}
+        connection.execute(query).each do |row|
+          result[row['function_name']] = row['comment']
+        end
+        result
+      end
     end
   end
 end