better_structure_sql 0.1.0 → 0.2.1

data/lib/better_structure_sql/generators/table_generator.rb

@@ -20,33 +20,58 @@ module BetterStructureSql
       # @return [String] SQL statement
       def generate(table)
         lines = ["CREATE TABLE IF NOT EXISTS #{table[:name]} ("]
+        lines << build_table_contents(table)
+        lines << ');'
+        lines.join("\n")
+      end
 
-        column_defs = table[:columns].map { |col| column_definition(col) }
-
-        if table[:primary_key]&.any?
-          # Quote primary key column names
-          pk_cols = table[:primary_key].map { |col| quote_column_name(col) }.join(', ')
-          column_defs << "PRIMARY KEY (#{pk_cols})"
-        end
+      private
 
-        table[:constraints]&.each do |constraint|
-          column_defs << constraint_definition(constraint)
-        end
+      # Build table contents (columns, primary key, constraints, foreign keys)
+      #
+      # @param table [Hash] Table metadata
+      # @return [String] Formatted table contents
+      def build_table_contents(table)
+        column_defs = build_column_definitions(table)
+        column_defs << build_primary_key_clause(table) if table[:primary_key]&.any?
+        column_defs.concat(build_constraints_clauses(table))
+        column_defs.concat(build_foreign_keys_clauses(table)) if sqlite_adapter? && table[:foreign_keys]&.any?
+
+        column_defs.map { |def_line| indent(def_line) }.join(",\n")
+      end
 
-        # For SQLite, add foreign keys inline
-        if sqlite_adapter? && table[:foreign_keys]&.any?
-          table[:foreign_keys].each do |fk|
-            column_defs << foreign_key_definition(fk)
-          end
-        end
+      # Build column definitions
+      #
+      # @param table [Hash] Table metadata
+      # @return [Array<String>] Array of column definition strings
+      def build_column_definitions(table)
+        table[:columns].map { |col| column_definition(col) }
+      end
 
-        lines << column_defs.map { |def_line| indent(def_line) }.join(",\n")
-        lines << ');'
+      # Build primary key clause
+      #
+      # @param table [Hash] Table metadata
+      # @return [String] PRIMARY KEY clause
+      def build_primary_key_clause(table)
+        pk_cols = table[:primary_key].map { |col| quote_column_name(col) }.join(', ')
+        "PRIMARY KEY (#{pk_cols})"
+      end
 
-        lines.join("\n")
+      # Build constraints clauses
+      #
+      # @param table [Hash] Table metadata
+      # @return [Array<String>] Array of constraint definition strings
+      def build_constraints_clauses(table)
+        table[:constraints]&.map { |constraint| constraint_definition(constraint) } || []
       end
 
-      private
+      # Build foreign keys clauses for SQLite
+      #
+      # @param table [Hash] Table metadata
+      # @return [Array<String>] Array of foreign key definition strings
+      def build_foreign_keys_clauses(table)
+        table[:foreign_keys].map { |fk| foreign_key_definition(fk) }
+      end
 
       def column_definition(column)
         # Quote column name for MySQL compatibility (reserved words like 'key')

data/lib/better_structure_sql/generators/type_generator.rb

@@ -26,19 +26,21 @@ module BetterStructureSql
 
       def generate_enum(type)
         values = type[:values].map { |v| "'#{v}'" }.join(', ')
-        "CREATE TYPE IF NOT EXISTS #{type[:name]} AS ENUM (#{values});"
+        "CREATE TYPE #{type[:name]} AS ENUM (#{values});"
       end
 
       def generate_composite(type)
         # Composite types have attributes
+        # Note: PostgreSQL does not support IF NOT EXISTS for composite types
         attrs = type[:attributes].map do |attr|
           "#{attr[:name]} #{attr[:type]}"
         end.join(', ')
-        "CREATE TYPE IF NOT EXISTS #{type[:name]} AS (#{attrs});"
+        "CREATE TYPE #{type[:name]} AS (#{attrs});"
       end
 
       def generate_domain(type)
-        parts = ["CREATE DOMAIN IF NOT EXISTS #{type[:name]} AS #{type[:base_type]}"]
+        # NOTE: PostgreSQL does not support IF NOT EXISTS for domains
+        parts = ["CREATE DOMAIN #{type[:name]} AS #{type[:base_type]}"]
         parts << type[:constraint] if type[:constraint]
         "#{parts.join(' ')};"
       end

data/lib/better_structure_sql/schema_loader.rb

@@ -35,10 +35,10 @@ module BetterStructureSql
       header_path = File.join(dir_path, '_header.sql')
       connection.execute(File.read(header_path)) if File.exist?(header_path)
 
-      # Load numbered directories in order (01_extensions through 10_migrations)
+      # Load numbered directories in order (01_extensions through 20_migrations)
       # Load all files in each directory and execute statements
-      # Use [01]* pattern to match directories starting with 0 or 1 (covers 01-10)
-      Dir.glob(File.join(dir_path, '[01]*_*')).sort.each do |dir|
+      # Use [012]* pattern to match directories starting with 0, 1, or 2 (covers 01-29)
+      Dir.glob(File.join(dir_path, '[012]*_*')).sort.each do |dir|
         next unless File.directory?(dir)
 
         dir_name = File.basename(dir)

data/lib/better_structure_sql/schema_version.rb

@@ -14,17 +14,25 @@ module BetterStructureSql
 
     # Validations
     validates :content, presence: true
+    validates :content_hash, presence: true,
+                             format: { with: /\A[a-f0-9]{32}\z/,
+                                       message: 'must be 32-character MD5 hex digest' }
     validates :pg_version, presence: true
     validates :format_type, presence: true, inclusion: { in: %w[sql rb] }
     validates :output_mode, presence: true, inclusion: { in: %w[single_file multi_file] }
 
     # Scopes
-    scope :latest, -> { order(created_at: :desc).first }
+    scope :latest_first, -> { order(created_at: :desc) }
     scope :by_format, ->(type) { where(format_type: type) }
     scope :by_output_mode, ->(mode) { where(output_mode: mode) }
     scope :recent, ->(limit) { order(created_at: :desc).limit(limit) }
     scope :oldest_first, -> { order(created_at: :asc) }
 
+    # Class method to get latest version
+    def self.latest
+      order(created_at: :desc).first
+    end
+
     # Instance methods
     def size
       # Use stored content_size if available and content hasn't changed
@@ -63,6 +71,14 @@ module BetterStructureSql
       zip_archive.present?
     end
 
+    # Compares this version's hash with another hash
+    #
+    # @param other_hash [String] Hash to compare against
+    # @return [Boolean] True if hashes match
+    def hash_matches?(other_hash)
+      content_hash == other_hash
+    end
+
     # Extracts ZIP archive to target directory
     #
     # @param target_dir [String, Pathname] Target directory path

data/lib/better_structure_sql/schema_versions.rb

@@ -6,8 +6,19 @@ module BetterStructureSql
   # Provides class methods for storing, querying, and managing
   # schema versions with automatic retention cleanup.
   module SchemaVersions
+    # Chunk size for streaming file reads (4MB)
+    # Balances memory efficiency with read performance
+    STREAM_CHUNK_SIZE = 4 * 1024 * 1024
+
     class << self
-      # Store current schema from file
+      # Store current schema from file with automatic deduplication
+      #
+      # Calculates content hash and compares with latest version.
+      # Skips storage if hash matches (no schema changes).
+      # Cleans up filesystem directory after storing ZIP (multi-file mode only).
+      #
+      # @param connection [ActiveRecord::Connection] Database connection
+      # @return [StoreResult] Result indicating stored or skipped
       def store_current(connection = ActiveRecord::Base.connection)
         config = BetterStructureSql.configuration
         pg_version = PgVersion.detect(connection)
@@ -16,13 +27,24 @@ module BetterStructureSql
         format_type = deduce_format_type(config.output_path)
         output_mode = detect_output_mode(config.output_path)
 
-        # Read content
+        # Read content and calculate hash
         content, zip_archive, file_count = read_schema_content(config.output_path, output_mode)
+        return build_skip_result(nil, count) unless content
 
-        return nil unless content
+        content_hash = calculate_hash(content)
+
+        # Compare with latest version's hash
+        ensure_table_exists!(connection)
+        latest_version = latest
+        if latest_version && latest_version.content_hash == content_hash
+          # Skip storage - no changes detected (directory remains for re-use)
+          return build_skip_result(latest_version, count)
+        end
 
-        store(
+        # Proceed with storage - hash differs or no previous versions
+        version = store(
           content: content,
+          content_hash: content_hash,
           zip_archive: zip_archive,
           format_type: format_type,
           output_mode: output_mode,
@@ -30,10 +52,26 @@ module BetterStructureSql
           file_count: file_count,
           connection: connection
         )
+
+        # Cleanup filesystem directory after ZIP stored (multi-file mode only)
+        cleanup_filesystem_directory(config.output_path, output_mode)
+
+        # Cleanup old versions (retention management)
+        cleanup!(connection)
+
+        # Return stored result
+        build_stored_result(version)
       end
 
       # Store schema version with explicit parameters
-      def store(content:, format_type:, pg_version:, **options)
+      #
+      # @param content [String] Schema content
+      # @param content_hash [String] MD5 hash of content (required)
+      # @param format_type [String] Format type ('sql' or 'rb')
+      # @param pg_version [String] PostgreSQL version
+      # @param options [Hash] Optional parameters (connection, output_mode, zip_archive, file_count)
+      # @return [SchemaVersion] Created version
+      def store(content:, content_hash:, format_type:, pg_version:, **options)
         connection = options.fetch(:connection, ActiveRecord::Base.connection)
         output_mode = options.fetch(:output_mode, 'single_file')
         zip_archive = options[:zip_archive]
@@ -41,8 +79,11 @@ module BetterStructureSql
 
         ensure_table_exists!(connection)
 
-        version = SchemaVersion.create!(
+        SchemaVersion.create!(
           content: content,
+          content_hash: content_hash,
+          content_size: content.bytesize,
+          line_count: content.count("\n"),
           zip_archive: zip_archive,
           format_type: format_type,
           output_mode: output_mode,
@@ -50,10 +91,6 @@ module BetterStructureSql
           file_count: file_count,
           created_at: Time.current
         )
-
-        cleanup!(connection)
-
-        version
       end
 
       # Retrieval methods
@@ -101,6 +138,121 @@ module BetterStructureSql
         SchemaVersion.by_format(format_type).order(created_at: :desc).to_a
       end
 
+      # Hash calculation methods
+
+      # Calculates MD5 hash of schema content
+      #
+      # @param content [String] Schema content to hash
+      # @return [String] 32-character MD5 hexdigest
+      # @raise [ArgumentError] If content is nil
+      def calculate_hash(content)
+        raise ArgumentError, 'Content cannot be nil' if content.nil?
+
+        require 'digest/md5'
+        Digest::MD5.hexdigest(content)
+      end
+
+      # Calculates hash from a single schema file using streaming
+      #
+      # Streams file in 4MB chunks to avoid loading entire file into memory.
+      # Efficient for large schema files (100MB+).
+      #
+      # @param path [String, Pathname] Path to schema file
+      # @return [String] 32-character MD5 hexdigest
+      # @raise [Errno::ENOENT] If file not found
+      def calculate_hash_from_file(path)
+        full_path = Rails.root.join(path)
+        raise Errno::ENOENT, "File not found: #{path}" unless File.exist?(full_path)
+
+        digest = Digest::MD5.new
+        File.open(full_path, 'rb') do |file|
+          while (chunk = file.read(STREAM_CHUNK_SIZE))
+            digest.update(chunk)
+          end
+        end
+        digest.hexdigest
+      end
+
+      # Calculates hash from multi-file schema directory using streaming
+      #
+      # Streams only .sql files (header + numbered directories) in order.
+      # Uses 4MB chunks for memory efficiency with large schemas.
+      #
+      # Note: Manifest JSON is excluded from hash calculation as it's metadata
+      # for tooling, not part of the actual schema content.
+      #
+      # @param path [String, Pathname] Path to schema directory
+      # @return [String] 32-character MD5 hexdigest
+      # @raise [Errno::ENOENT] If directory not found
+      def calculate_hash_from_directory(path)
+        full_path = Rails.root.join(path)
+        raise Errno::ENOENT, "Directory not found: #{path}" unless Dir.exist?(full_path)
+
+        digest = Digest::MD5.new
+
+        # Stream _header.sql if exists
+        header_path = full_path.join('_header.sql')
+        stream_file_to_digest(digest, header_path) if File.exist?(header_path)
+
+        # Stream all .sql files from numbered directories in order (01_ through 10_)
+        Dir.glob(File.join(full_path, '*_*')).select { |f| File.directory?(f) }.sort.each do |dir|
+          Dir.glob(File.join(dir, '*.sql')).sort.each do |file|
+            stream_file_to_digest(digest, file)
+          end
+        end
+
+        digest.hexdigest
+      end
+
+      # Combined read and hash operation
+      #
+      # @param output_path [String, Pathname] Path to schema file or directory
+      # @param output_mode [String] 'single_file' or 'multi_file'
+      # @return [Array<String, String, String, Integer>] content, content_hash, zip_archive, file_count
+      def read_and_hash_content(output_path, output_mode)
+        content, zip_archive, file_count = read_schema_content(output_path, output_mode)
+        return [nil, nil, nil, nil] unless content
+
+        content_hash = calculate_hash(content)
+        [content, content_hash, zip_archive, file_count]
+      end
+
+      # Hash query methods
+
+      # Retrieves content_hash of the most recent schema version
+      #
+      # @param _connection [ActiveRecord::Connection] Database connection (optional)
+      # @return [String, nil] Hash of latest version or nil if no versions exist
+      def latest_hash(_connection = ActiveRecord::Base.connection)
+        return nil unless table_exists?
+
+        SchemaVersion.latest&.content_hash
+      end
+
+      # Checks if a content hash exists in stored versions
+      #
+      # @param hash [String] Content hash to search for
+      # @param _connection [ActiveRecord::Connection] Database connection (optional)
+      # @return [Boolean] True if hash found, false otherwise
+      def hash_exists?(hash, _connection = ActiveRecord::Base.connection)
+        return false unless table_exists?
+
+        SchemaVersion.exists?(content_hash: hash)
+      end
+
+      # Finds schema version by content hash
+      #
+      # Returns most recent version if multiple versions have the same hash.
+      #
+      # @param hash [String] Content hash to search for
+      # @param _connection [ActiveRecord::Connection] Database connection (optional)
+      # @return [SchemaVersion, nil] Found version or nil
+      def find_by_hash(hash, _connection = ActiveRecord::Base.connection)
+        return nil unless table_exists?
+
+        SchemaVersion.where(content_hash: hash).order(created_at: :desc).first
+      end
+
       # Retention management
       def cleanup!(_connection = ActiveRecord::Base.connection)
         return 0 unless table_exists?
@@ -129,6 +281,64 @@ module BetterStructureSql
 
       private
 
+      # Builds a skip result when storage is not needed
+      #
+      # @param version [SchemaVersion, nil] Existing version that matched
+      # @param total_count [Integer] Total version count
+      # @return [StoreResult] Skip result
+      def build_skip_result(version, total_count)
+        StoreResult.new(
+          skipped: true,
+          version_id: version&.id,
+          hash: version&.content_hash,
+          total_count: total_count
+        )
+      end
+
+      # Builds a stored result when new version was created
+      #
+      # @param version [SchemaVersion] Newly created version
+      # @return [StoreResult] Stored result
+      def build_stored_result(version)
+        StoreResult.new(
+          skipped: false,
+          version: version,
+          total_count: count
+        )
+      end
+
+      # Cleanup filesystem directory after ZIP archive stored
+      #
+      # Only removes multi-file directories (single files remain).
+      # Gracefully handles errors without failing the storage operation.
+      #
+      # @param output_path [String, Pathname] Path to directory
+      # @param output_mode [String] Output mode ('single_file' or 'multi_file')
+      def cleanup_filesystem_directory(output_path, output_mode)
+        # Only cleanup multi-file directories (single files remain)
+        return unless output_mode == 'multi_file'
+
+        full_path = Rails.root.join(output_path)
+        return unless Dir.exist?(full_path)
+
+        FileUtils.rm_rf(full_path)
+      rescue StandardError => e
+        warn "Warning: Failed to cleanup directory #{output_path}: #{e.message}"
+        # Continue despite cleanup failure - version already stored
+      end
+
+      # Streams a file to digest using STREAM_CHUNK_SIZE chunks
+      #
+      # @param digest [Digest::MD5] Digest instance to update
+      # @param file_path [String, Pathname] Path to file
+      def stream_file_to_digest(digest, file_path)
+        File.open(file_path, 'rb') do |file|
+          while (chunk = file.read(STREAM_CHUNK_SIZE))
+            digest.update(chunk)
+          end
+        end
+      end
+
       def read_schema_content(output_path, output_mode)
         case output_mode
         when 'single_file'
@@ -158,19 +368,12 @@ module BetterStructureSql
       def read_multi_file_content(base_path)
         content_parts = []
 
-        # Read header
+        # Read _header.sql if exists
         header_path = base_path.join('_header.sql')
         content_parts << File.read(header_path) if File.exist?(header_path)
 
-        # Read manifest and embed as SQL comment for later extraction
-        manifest_path = base_path.join('_manifest.json')
-        if File.exist?(manifest_path)
-          manifest_json = File.read(manifest_path)
-          content_parts << "-- MANIFEST_JSON_START\n-- #{manifest_json.gsub("\n", "\n-- ")}\n-- MANIFEST_JSON_END"
-        end
-
-        # Read numbered directories in order (01_ through 10_)
-        # Use pattern that works with Dir.glob
+        # Read all .sql files from numbered directories in order (01_ through 10_)
+        # Note: Manifest JSON is excluded as it's metadata, not schema content
         Dir.glob(File.join(base_path, '*_*')).select { |f| File.directory?(f) }.sort.each do |dir|
           Dir.glob(File.join(dir, '*.sql')).sort.each do |file|
             content_parts << File.read(file)

data/lib/better_structure_sql/store_result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  # Value object encapsulating schema version storage operation result
+  #
+  # Provides clean separation between storage logic and output formatting.
+  # Used by SchemaVersions.store_current to indicate whether storage occurred
+  # or was skipped due to duplicate content hash.
+  #
+  # @example Stored result
+  #   version = SchemaVersion.create!(content: "...", content_hash: "abc123")
+  #   result = StoreResult.new(skipped: false, version: version)
+  #   result.stored? # => true
+  #   result.version_id # => 5
+  #
+  # @example Skipped result
+  #   result = StoreResult.new(skipped: true, version_id: 3, hash: "abc123")
+  #   result.skipped? # => true
+  #   result.version_id # => 3
+  class StoreResult
+    attr_reader :version, :version_id, :hash, :total_count
+
+    # @param skipped [Boolean] Whether storage was skipped
+    # @param version [SchemaVersion, nil] Created version (when stored)
+    # @param version_id [Integer, nil] Existing version ID (when skipped)
+    # @param hash [String, nil] Content hash
+    # @param total_count [Integer, nil] Total version count after operation
+    def initialize(skipped:, version: nil, version_id: nil, hash: nil, total_count: nil)
+      @skipped = skipped
+      @version = version
+      @version_id = version_id || version&.id
+      @hash = hash || version&.content_hash
+      @total_count = total_count
+    end
+
+    # @return [Boolean] True if storage was skipped due to duplicate hash
+    def skipped?
+      @skipped
+    end
+
+    # @return [Boolean] True if new version was stored
+    def stored?
+      !@skipped
+    end
+  end
+end

data/lib/better_structure_sql/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BetterStructureSql
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

data/lib/better_structure_sql.rb

@@ -2,11 +2,12 @@
 
 require 'active_record'
 require_relative 'better_structure_sql/version'
+require_relative 'better_structure_sql/errors'
 require_relative 'better_structure_sql/adapters/base_adapter'
 require_relative 'better_structure_sql/adapters/postgresql_config'
 require_relative 'better_structure_sql/adapters/registry'
 require_relative 'better_structure_sql/configuration'
-require_relative 'better_structure_sql/dependency_resolver'
+# require_relative 'better_structure_sql/dependency_resolver' # TODO: Not yet integrated, implement in future phase
 require_relative 'better_structure_sql/introspection'
 require_relative 'better_structure_sql/formatter'
 require_relative 'better_structure_sql/generators/base'
@@ -21,9 +22,11 @@ require_relative 'better_structure_sql/generators/materialized_view_generator'
 require_relative 'better_structure_sql/generators/function_generator'
 require_relative 'better_structure_sql/generators/trigger_generator'
 require_relative 'better_structure_sql/generators/domain_generator'
+require_relative 'better_structure_sql/generators/comment_generator'
 require_relative 'better_structure_sql/database_version'
 require_relative 'better_structure_sql/pg_version'
 require_relative 'better_structure_sql/schema_version'
+require_relative 'better_structure_sql/store_result'
 require_relative 'better_structure_sql/schema_versions'
 require_relative 'better_structure_sql/file_writer'
 require_relative 'better_structure_sql/manifest_generator'

data/lib/generators/better_structure_sql/templates/README

@@ -44,6 +44,6 @@ Coming in Phase 3:
   - Advanced PostgreSQL features
 
 For more information, visit:
-  https://github.com/example/better_structure_sql
+  https://github.com/sebyx07/better_structure_sql
 
 ===============================================================================

data/lib/generators/better_structure_sql/templates/migration.rb.erb

@@ -2,6 +2,7 @@ class CreateBetterStructureSqlSchemaVersions < ActiveRecord::Migration<%= migrat
   def change
     create_table :better_structure_sql_schema_versions do |t|
       t.text :content, null: false
+      t.string :content_hash, limit: 32, null: false
       t.binary :zip_archive, null: true
       t.string :pg_version, null: false
       t.string :format_type, null: false
@@ -13,6 +14,7 @@ class CreateBetterStructureSqlSchemaVersions < ActiveRecord::Migration<%= migrat
     end
 
     add_index :better_structure_sql_schema_versions, :created_at, order: { created_at: :desc }
+    add_index :better_structure_sql_schema_versions, :content_hash
     add_index :better_structure_sql_schema_versions, :output_mode
 
     add_check_constraint :better_structure_sql_schema_versions,

data/lib/tasks/better_structure_sql.rake

@@ -73,53 +73,70 @@ namespace :db do
     task store: :environment do
       require 'better_structure_sql'
 
-      unless BetterStructureSql.configuration.enable_schema_versions
+      config = BetterStructureSql.configuration
+      unless config.enable_schema_versions
         puts 'Schema versioning is not enabled.'
         puts 'Enable it in config/initializers/better_structure_sql.rb:'
         puts '  config.enable_schema_versions = true'
-        exit 1
+        next
       end
 
-      version = BetterStructureSql::SchemaVersions.store_current
-
-      if version
-        puts 'Schema version stored successfully'
-        puts "  ID: #{version.id}"
+      connection = ActiveRecord::Base.connection
+      result = BetterStructureSql::SchemaVersions.store_current(connection)
+
+      if result.skipped?
+        puts "\nNo schema changes detected"
+        puts "  Current schema matches version ##{result.version_id}"
+        puts "  Hash: #{result.hash}"
+        puts '  No new version stored'
+        puts "  Total versions: #{result.total_count}"
+      elsif result.stored?
+        version = result.version
+        puts "\nStored schema version ##{version.id}"
         puts "  Format: #{version.format_type}"
         puts "  Mode: #{version.output_mode}"
-        puts "  Files: #{version.file_count || 1}"
+        puts "  Files: #{version.file_count}" if version.multi_file?
         puts "  PostgreSQL: #{version.pg_version}"
         puts "  Size: #{version.formatted_size}"
-        puts "  Total versions: #{BetterStructureSql::SchemaVersions.count}"
+        puts "  Hash: #{version.content_hash}"
+        puts "  Total versions: #{result.total_count}"
       else
-        puts 'No schema file found to store'
+        puts "\nNo schema file found to store"
         exit 1
       end
+    rescue StandardError => e
+      puts "\nError storing schema version: #{e.message}"
+      puts e.backtrace.first(5).join("\n") if ENV['VERBOSE']
+      exit 1
     end
 
     desc 'List all stored schema versions'
     task versions: :environment do
       require 'better_structure_sql'
 
-      unless BetterStructureSql.configuration.enable_schema_versions
+      config = BetterStructureSql.configuration
+      unless config.enable_schema_versions
         puts 'Schema versioning is not enabled.'
-        exit 1
+        puts 'Enable it in config/initializers/better_structure_sql.rb:'
+        puts '  config.enable_schema_versions = true'
+        next
       end
 
       versions = BetterStructureSql::SchemaVersions.all_versions
       if versions.empty?
         puts 'No schema versions stored yet'
       else
-        puts "Total versions: #{versions.count}"
-        puts "\nID     Format  Mode          Files   PostgreSQL      Created              Size"
-        puts '-' * 95
+        puts "\nSchema Versions (#{versions.count} total)\n\n"
+        puts 'ID   | Format | Mode        | Files | PostgreSQL | Hash     | Created             | Size'
+        puts '-' * 100
         versions.each do |version|
-          puts format('%-6d %-7s %-13s %-7s %-15s %-20s %s',
+          puts format('%-4d | %-6s | %-11s | %-5s | %-10s | %-8s | %-19s | %s',
                       version.id,
                       version.format_type,
                       version.output_mode,
-                      version.file_count || 1,
-                      version.pg_version,
+                      version.file_count || '-',
+                      version.pg_version[0..9], # Truncate long version strings
+                      version.content_hash[0..7], # First 8 chars of hash
                       version.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                       version.formatted_size)
         end