rails_lens 0.0.0 → 0.2.2

data/lib/rails_lens/schema/adapters/mysql.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Schema
+    module Adapters
+      class Mysql < Base
+        def adapter_name
+          'MySQL'
+        end
+
+        def generate_annotation(_model_class)
+          lines = []
+          lines << "table = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Add storage engine information
+          if (engine = table_storage_engine)
+            lines << "storage_engine = \"#{engine}\""
+          end
+
+          # Add character set and collation
+          if (charset = table_charset)
+            lines << "character_set = \"#{charset}\""
+          end
+
+          if (collation = table_collation)
+            lines << "collation = \"#{collation}\""
+          end
+
+          lines << ''
+
+          add_columns_toml(lines)
+          add_indexes_toml(lines) if show_indexes?
+          add_foreign_keys_toml(lines) if show_foreign_keys?
+          add_partitions_toml(lines) if has_partitions?
+
+          lines.join("\n")
+        end
+
+        protected
+
+        def format_column(column)
+          parts = []
+          parts << column.name.ljust(column_name_width)
+
+          # MySQL specific type formatting
+          type_string = format_column_type(column)
+          parts << ":#{type_string.ljust(12)}"
+
+          attributes = []
+          attributes << 'not null' unless column.null
+          attributes << 'primary key' if primary_key?(column)
+
+          # MySQL specific: show auto_increment
+          attributes << 'auto_increment' if primary_key?(column) && column.extra == 'auto_increment'
+
+          # Show character set and collation for string columns
+          if %i[string text].include?(column.type) && column.respond_to?(:charset)
+            attributes << "charset: #{column.charset}" if column.charset
+            attributes << "collation: #{column.collation}" if column.collation
+          end
+
+          attributes << "default: #{format_default(column.default)}" if column.default && show_defaults?
+
+          # Add column comment if available
+          if show_comments? && column.respond_to?(:comment) && column.comment
+            attributes << "comment: \"#{column.comment}\""
+          end
+
+          parts << attributes.join(', ') unless attributes.empty?
+
+          " #{parts.join(' ')}"
+        end
+
+        def format_column_type(column)
+          case column.type
+          when :string
+            column.limit ? "varchar(#{column.limit})" : 'varchar'
+          when :text
+            case column.limit
+            when 0..255 then 'tinytext'
+            when 256..65_535 then 'text'
+            when 65_536..16_777_215 then 'mediumtext'
+            else 'longtext'
+            end
+          when :binary
+            case column.limit
+            when 0..255 then 'tinyblob'
+            when 256..65_535 then 'blob'
+            when 65_536..16_777_215 then 'mediumblob'
+            else 'longblob'
+            end
+          when :integer
+            # MySQL integer types
+            case column.limit
+            when 1 then 'tinyint'
+            when 2 then 'smallint'
+            when 3 then 'mediumint'
+            when 8 then 'bigint'
+            else 'int'
+            end
+          else
+            column.sql_type || column.type.to_s
+          end
+        end
+
+        def table_storage_engine
+          result = connection.execute("SHOW TABLE STATUS LIKE '#{table_name}'").first
+          return nil unless result
+
+          # Handle both hash and array results from different MySQL adapters
+          if result.is_a?(Hash)
+            result['Engine']
+          elsif result.is_a?(Array)
+            result[1] # Engine is typically the second column
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          Rails.logger.debug { "Failed to fetch storage engine for #{table_name}: #{e.message}" }
+          nil
+        rescue => e
+          Rails.logger.debug { "MySQL error fetching storage engine: #{e.message}" }
+          nil
+        end
+
+        def table_charset
+          result = connection.execute("SHOW TABLE STATUS LIKE '#{table_name}'").first
+          return nil unless result
+
+          # Handle both hash and array results from different MySQL adapters
+          collation = if result.is_a?(Hash)
+                        result['Collation']
+                      elsif result.is_a?(Array)
+                        result[14] # Collation is typically the 15th column
+                      end
+
+          collation&.split('_')&.first
+        rescue ActiveRecord::StatementInvalid => e
+          Rails.logger.debug { "Failed to fetch charset for #{table_name}: #{e.message}" }
+          nil
+        rescue => e
+          Rails.logger.debug { "MySQL error fetching charset: #{e.message}" }
+          nil
+        end
+
+        def table_collation
+          result = connection.execute("SHOW TABLE STATUS LIKE '#{table_name}'").first
+          return nil unless result
+
+          # Handle both hash and array results from different MySQL adapters
+          if result.is_a?(Hash)
+            result['Collation']
+          elsif result.is_a?(Array)
+            result[14] # Collation is typically the 15th column
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          Rails.logger.debug { "Failed to fetch collation for #{table_name}: #{e.message}" }
+          nil
+        rescue => e
+          Rails.logger.debug { "MySQL error fetching collation: #{e.message}" }
+          nil
+        end
+
+        def format_index(index)
+          base = " #{index.name}"
+
+          columns = Array(index.columns).join(', ')
+          base += " (#{columns})"
+
+          attributes = []
+          attributes << 'UNIQUE' if index.unique
+          attributes << 'FULLTEXT' if index.type == 'FULLTEXT'
+          attributes << 'SPATIAL' if index.type == 'SPATIAL'
+
+          # Show index type (BTREE, HASH)
+          attributes << "USING #{index.using}" if index.respond_to?(:using) && index.using
+
+          base += " #{attributes.join(' ')}" unless attributes.empty?
+          base
+        end
+
+        def has_partitions?
+          return false unless connection.respond_to?(:execute)
+
+          result = connection.execute(<<-SQL.squish)
+          SELECT COUNT(*) as count
+          FROM information_schema.partitions
+          WHERE table_schema = DATABASE()
+            AND table_name = '#{table_name}'
+            AND partition_name IS NOT NULL
+          SQL
+
+          count = if result.first.is_a?(Hash)
+                    result.first['count'] || result.first[:count]
+                  elsif result.first.is_a?(Array)
+                    result.first[0] # count is the first column
+                  else
+                    0
+                  end
+
+          count.to_i.positive?
+        rescue ActiveRecord::StatementInvalid => e
+          # Table doesn't exist or no permission to query information_schema
+          Rails.logger.debug { "Failed to check partitions for #{table_name}: #{e.message}" }
+          false
+        rescue => e
+          # MySQL specific errors (connection issues, etc)
+          Rails.logger.debug { "MySQL error checking partitions: #{e.message}" }
+          false
+        end
+
+        def add_partitions(lines)
+          return unless connection.respond_to?(:execute)
+
+          partitions = connection.execute(<<-SQL.squish)
+          SELECT partition_name, partition_expression, partition_description
+          FROM information_schema.partitions
+          WHERE table_schema = DATABASE()
+            AND table_name = '#{table_name}'
+            AND partition_name IS NOT NULL
+          ORDER BY partition_ordinal_position
+          SQL
+
+          return if partitions.none?
+
+          lines << '' unless lines.last && lines.last.empty?
+          lines << 'Partitions:'
+
+          partitions.each do |partition|
+            lines << " #{partition['partition_name']}: #{partition['partition_description']}"
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          # Permission denied or table doesn't exist
+          Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
+        rescue => e
+          # MySQL specific errors
+          Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
+        end
+
+        def add_partitions_toml(lines)
+          return unless connection.respond_to?(:execute)
+
+          partitions = connection.execute(<<-SQL.squish)
+          SELECT partition_name, partition_expression, partition_description
+          FROM information_schema.partitions
+          WHERE table_schema = DATABASE()
+            AND table_name = '#{table_name}'
+            AND partition_name IS NOT NULL
+          ORDER BY partition_ordinal_position
+          SQL
+
+          return if partitions.none?
+
+          lines << ''
+          lines << 'partitions = ['
+
+          partitions.each_with_index do |partition, i|
+            line = '  { '
+            attrs = []
+            attrs << "name = \"#{partition['partition_name']}\""
+            attrs << "description = \"#{partition['partition_description']}\""
+            attrs << "expression = \"#{partition['partition_expression']}\"" if partition['partition_expression']
+            line += attrs.join(', ')
+            line += ' }'
+            line += ',' if i < partitions.count - 1
+            lines << line
+          end
+
+          lines << ']'
+        rescue ActiveRecord::StatementInvalid => e
+          # Permission denied or table doesn't exist
+          Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
+        rescue => e
+          # MySQL specific errors
+          Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/schema/adapters/postgresql.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Schema
+    module Adapters
+      class Postgresql < Base
+        def adapter_name
+          'PostgreSQL'
+        end
+
+        def generate_annotation(_model_class)
+          lines = []
+          lines << "table = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Add schema information for PostgreSQL
+          lines << "schema = \"#{schema_name}\"" if schema_name && schema_name != 'public'
+          lines << ''
+
+          add_columns_toml(lines)
+          add_indexes_toml(lines) if show_indexes?
+          add_foreign_keys_toml(lines) if show_foreign_keys?
+          add_check_constraints_toml(lines) if show_check_constraints?
+          add_table_comment_toml(lines) if show_comments?
+
+          lines.join("\n")
+        end
+
+        protected
+
+        def schema_name
+          @schema_name ||= if table_name.include?('.')
+                             table_name.split('.').first
+                           elsif connection.respond_to?(:current_schema)
+                             connection.current_schema
+                           end
+        end
+
+        def format_column(column)
+          parts = []
+          parts << column.name.ljust(column_name_width)
+
+          # PostgreSQL specific type formatting
+          type_string = format_column_type(column)
+          parts << ":#{type_string.ljust(12)}"
+
+          attributes = []
+          attributes << 'not null' unless column.null
+          attributes << 'primary key' if primary_key?(column)
+
+          # Show sequence for serial columns
+          if column.default&.match?(/nextval/)
+            attributes << "default: nextval('#{extract_sequence_name(column.default)}')"
+          elsif column.default && show_defaults?
+            attributes << "default: #{format_default(column.default)}"
+          end
+
+          # Add column comment if available
+          if show_comments? && (comment = column_comment(column.name))
+            attributes << "comment: \"#{comment}\""
+          end
+
+          parts << attributes.join(', ') unless attributes.empty?
+
+          " #{parts.join(' ')}"
+        end
+
+        def format_column_type(column)
+          case column.type
+          when :string
+            column.limit ? "string(#{column.limit})" : 'string'
+          when :decimal
+            if column.precision && column.scale
+              "decimal(#{column.precision},#{column.scale})"
+            else
+              'decimal'
+            end
+          when :integer
+            case column.limit
+            when 2 then 'smallint'
+            when 8 then 'bigint'
+            else 'integer'
+            end
+          else
+            column.sql_type || column.type.to_s
+          end
+        end
+
+        def extract_sequence_name(default_value)
+          default_value.match(/nextval\('([^']+)'/)&.captures&.first || 'sequence'
+        end
+
+        def format_foreign_key(fk)
+          base = " #{fk.name} (#{fk.column} => #{fk.to_table}.#{fk.primary_key})"
+
+          # Add cascade options
+          options = []
+          options << "ON DELETE #{fk.on_delete.upcase}" if fk.on_delete
+          options << "ON UPDATE #{fk.on_update.upcase}" if fk.on_update
+
+          base += " #{options.join(' ')}" unless options.empty?
+          base
+        end
+
+        def fetch_check_constraints
+          return [] unless connection.supports_check_constraints?
+
+          connection.check_constraints(table_name).map do |constraint|
+            {
+              name: constraint.name,
+              expression: constraint.expression
+            }
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          # Table doesn't exist or other database error
+          Rails.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
+          []
+        rescue PG::Error => e
+          # PostgreSQL specific errors
+          Rails.logger.debug { "PostgreSQL error fetching check constraints: #{e.message}" }
+          []
+        end
+
+        def column_comment(column_name)
+          return nil unless connection.respond_to?(:column_comment)
+
+          connection.column_comment(table_name, column_name)
+        rescue ActiveRecord::StatementInvalid => e
+          # Table or column doesn't exist
+          Rails.logger.debug { "Failed to fetch column comment for #{table_name}.#{column_name}: #{e.message}" }
+          nil
+        rescue PG::Error => e
+          # PostgreSQL specific errors
+          Rails.logger.debug { "PostgreSQL error fetching column comment: #{e.message}" }
+          nil
+        end
+
+        def table_comment
+          return nil unless connection.respond_to?(:table_comment)
+
+          connection.table_comment(table_name)
+        rescue ActiveRecord::StatementInvalid => e
+          # Table doesn't exist
+          Rails.logger.debug { "Failed to fetch table comment for #{table_name}: #{e.message}" }
+          nil
+        rescue PG::Error => e
+          # PostgreSQL specific errors
+          Rails.logger.debug { "PostgreSQL error fetching table comment: #{e.message}" }
+          nil
+        end
+
+        def add_table_comment(lines)
+          comment = table_comment
+          return unless comment
+
+          lines << '' unless lines.last && lines.last.empty?
+          lines << 'Table Comment:'
+          lines << " #{comment}"
+        end
+
+        def format_index(index)
+          base = " #{index.name}"
+
+          # Show column names
+          columns = Array(index.columns).join(', ')
+          base += " (#{columns})"
+
+          # Index type
+          attributes = []
+          attributes << 'UNIQUE' if index.unique
+          attributes << "USING #{index.using.upcase}" if index.respond_to?(:using) && index.using
+          attributes << "WHERE #{index.where}" if index.respond_to?(:where) && index.where
+
+          base += " #{attributes.join(' ')}" unless attributes.empty?
+          base
+        end
+
+        def add_columns(lines)
+          lines << 'Columns:'
+
+          # Group columns by type for better readability
+          columns.each do |column|
+            lines << format_column(column)
+          end
+        end
+
+        def add_table_comment_toml(lines)
+          comment = table_comment
+          return unless comment
+
+          lines << ''
+          lines << "table_comment = \"#{comment.gsub('"', '\"')}\""
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/schema/adapters/sqlite3.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Schema
+    module Adapters
+      class Sqlite3 < Base
+        def adapter_name
+          'SQLite'
+        end
+
+        def generate_annotation(_model_class)
+          lines = []
+          lines << "table = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+          lines << ''
+
+          add_columns_toml(lines)
+          add_indexes_toml(lines) if show_indexes?
+          add_foreign_keys_toml(lines) if show_foreign_keys?
+          add_sqlite_pragmas_toml(lines)
+
+          lines.join("\n")
+        end
+
+        protected
+
+        def format_column(column)
+          parts = []
+          parts << column.name.ljust(column_name_width)
+          parts << ":#{column.type.to_s.ljust(12)}"
+
+          attributes = []
+          attributes << 'not null' unless column.null
+          attributes << 'primary key' if primary_key?(column)
+
+          # SQLite3 specific: show auto-increment info
+          attributes << 'autoincrement' if primary_key?(column) && column.type == :integer
+
+          attributes << "default: #{format_default(column.default)}" if column.default && show_defaults?
+
+          parts << attributes.join(', ') unless attributes.empty?
+
+          " #{parts.join(' ')}"
+        end
+
+        def fetch_indexes
+          # SQLite3 returns different index info, filter out auto-generated ones
+          super.reject { |index| index.name =~ /^sqlite_autoindex/ }
+        end
+
+        def fetch_check_constraints
+          # SQLite3 stores check constraints in table info
+          # This would require raw SQL queries to extract
+          []
+        end
+
+        def add_sqlite_pragmas_structured(lines)
+          # Add SQLite-specific information if needed
+          return unless connection.respond_to?(:execute)
+
+          begin
+            # Example: Foreign keys status
+            fk_status = connection.execute('PRAGMA foreign_keys').first
+            lines << 'FOREIGN_KEYS_ENABLED: false' if fk_status && fk_status['foreign_keys'].zero?
+          rescue ActiveRecord::StatementInvalid => e
+            # SQLite doesn't recognize the pragma or access denied
+            Rails.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
+          rescue SQLite3::Exception => e
+            # SQLite specific errors (database locked, etc)
+            Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
+          end
+        end
+
+        def add_sqlite_pragmas_toml(lines)
+          # Add SQLite-specific information if needed
+          return unless connection.respond_to?(:execute)
+
+          begin
+            # Example: Foreign keys status
+            fk_status = connection.execute('PRAGMA foreign_keys').first
+            if fk_status && fk_status['foreign_keys'].zero?
+              lines << ''
+              lines << 'foreign_keys_enabled = false'
+            end
+          rescue ActiveRecord::StatementInvalid => e
+            # SQLite doesn't recognize the pragma or access denied
+            Rails.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
+          rescue SQLite3::Exception => e
+            # SQLite specific errors (database locked, etc)
+            Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
+          end
+        end
+      end
+    end
+  end
+end