git-pkgs 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ff583fee83b937717da50de39743a8cfa5a75ce987df064edeaf89ea713f90f
-  data.tar.gz: eea893e5bacae2af0f2fdf8a8c1736f1d080a4b4bb111a2b94891f481f65c805
+  metadata.gz: 456f37ab775f4c2262efc63bb71a3d9e9901a69dcd6b78f08a7eacbe1f3991d2
+  data.tar.gz: a4e20b318a4244ddebbd34710ffb75ba79c8e96d17183c646b10fbc07e57e0cc
 SHA512:
-  metadata.gz: 95795186a511d176679a98a4f6e8e246bb1548456f041c3e5379d9705d3382deac69df2d81f0d187c294ba9af164f8c8372724b1f228326784a32a2952c98b98
-  data.tar.gz: 8fffd3620a9bfe95b4aa46e51c80dad6db2984829f653f6f28eccfc7d5a7c19aa480a20f7c7be30a929d1fe23cdfe6e368a2a529c9b2204319102ff9d1bbd9cd
+  metadata.gz: 6d2e71fa0e93fd21a9364f641bfab05d90c71cf76b5bd19b02cf03064d205070aa49ffe99780cda4d5004a9aabc27ea6c47692e28f2457ed6671af3b94e4661b
+  data.tar.gz: 8f3ce053d35962a58c66d70c00f3f0ba9510ebd8116ee01e388f6d967ce7f64cc20cf7e6b86aee9d03316a28a80a21836678e4c8e5b71f2b19c2c6a17294939a

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.6.0] - 2026-01-05
+
+- Replace ActiveRecord with Sequel (~3x faster init, ~2x faster queries)
+- `git pkgs stats` now shows top authors in default output
+- Update ecosystems-bibliothecary to ~> 15.0 (~10x faster lockfile parsing)
+- Fewer runtime dependencies
+- Quieter output from `init` and `update` commands
+
 ## [0.5.0] - 2026-01-04
 
 - `git pkgs init` now installs git hooks by default (use `--no-hooks` to skip)

data/README.md

@@ -429,9 +429,7 @@ Optimizations:
 
 git-pkgs uses [ecosystems-bibliothecary](https://github.com/ecosyste-ms/bibliothecary) for parsing, supporting:
 
-Actions, BentoML, Bower, Cargo, CocoaPods, Cog, Conda, CPAN, CRAN, Docker, Dub, DVC, Elm, Go, Haxelib, Homebrew, Julia, Maven, Meteor, MLflow, npm, NuGet, Ollama, Packagist, Pub, PyPI, RubyGems, Shards, Vcpkg
-
-Some ecosystems require remote parsing services and are disabled by default: Carthage, Clojars, Hackage, Hex, SwiftPM. Enable with `git config --add pkgs.ecosystems <name>`.
+Actions, BentoML, Bower, Cargo, Carthage, Clojars, CocoaPods, Cog, Conda, CPAN, CRAN, Docker, Dub, DVC, Elm, Go, Hackage, Haxelib, Hex, Homebrew, Julia, Maven, Meteor, MLflow, npm, NuGet, Ollama, Packagist, Pub, PyPI, RubyGems, Shards, SwiftPM, Vcpkg
 
 SBOM formats (CycloneDX, SPDX) are not supported as they duplicate information from the actual lockfiles.
 

data/lib/git/pkgs/commands/blame.rb

@@ -19,12 +19,12 @@ module Git
 
           # Get current dependencies at the last analyzed commit
           branch_name = @options[:branch] || repo.default_branch
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
 
           error "No analysis found for branch '#{branch_name}'. Run 'git pkgs init' first." unless branch&.last_analyzed_sha
 
-          current_commit = Models::Commit.find_by(sha: branch.last_analyzed_sha)
-          snapshots = current_commit&.dependency_snapshots&.includes(:manifest) || []
+          current_commit = Models::Commit.first(sha: branch.last_analyzed_sha)
+          snapshots = current_commit&.dependency_snapshots&.eager(:manifest) || []
 
           if @options[:ecosystem]
             snapshots = snapshots.where(ecosystem: @options[:ecosystem])
@@ -41,7 +41,7 @@ module Git
           names = snapshots.map(&:name).uniq
 
           all_added_changes = Models::DependencyChange
-            .includes(:commit)
+            .eager(:commit)
             .added
             .where(manifest_id: manifest_ids, name: names)
             .to_a

data/lib/git/pkgs/commands/branch.rb

@@ -50,7 +50,7 @@ module Git
 
           error "Branch '#{branch_name}' not found. Check 'git branch -a' for available branches." unless repo.branch_exists?(branch_name)
 
-          existing = Models::Branch.find_by(name: branch_name)
+          existing = Models::Branch.first(name: branch_name)
           if existing
             info "Branch '#{branch_name}' already tracked (#{existing.commits.count} commits)"
             info "Use 'git pkgs update' to refresh"
@@ -59,7 +59,7 @@ module Git
 
           Database.optimize_for_bulk_writes
 
-          branch = Models::Branch.create!(name: branch_name)
+          branch = Models::Branch.create(name: branch_name)
           analyzer = Analyzer.new(repo)
 
           info "Analyzing branch: #{branch_name}"
@@ -100,7 +100,7 @@ module Git
           puts "Tracked branches:"
           branches.each do |branch|
             commit_count = branch.commits.count
-            dep_commits = branch.commits.where(has_dependency_changes: true).count
+            dep_commits = branch.commits_dataset.where(has_dependency_changes: true).count
             last_sha = branch.last_analyzed_sha&.slice(0, 7) || "none"
             puts "  #{branch.name}: #{commit_count} commits (#{dep_commits} with deps), last: #{last_sha}"
           end
@@ -115,13 +115,13 @@ module Git
 
           Database.connect(repo.git_dir)
 
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
           error "Branch '#{branch_name}' not tracked. Run 'git pkgs branch list' to see tracked branches." unless branch
 
           # Only delete branch_commits, keep shared commits
           count = branch.branch_commits.count
-          branch.branch_commits.delete_all
-          branch.destroy
+          branch.branch_commits_dataset.delete
+          branch.delete
 
           info "Removed branch '#{branch_name}' (#{count} branch-commit links)"
         end
@@ -143,28 +143,27 @@ module Git
           flush = lambda do
             return if pending_commits.empty?
 
-            ActiveRecord::Base.transaction do
-              # Use upsert for commits since they may already exist from other branches
+            Database.db.transaction do
+              # Use insert with on_conflict for commits since they may already exist from other branches
               if pending_commits.any?
-                Models::Commit.upsert_all(
-                  pending_commits,
-                  unique_by: :sha
-                )
+                Models::Commit.dataset
+                  .insert_conflict(target: :sha, update: { has_dependency_changes: Sequel[:excluded][:has_dependency_changes] })
+                  .multi_insert(pending_commits)
               end
 
               commit_ids = Models::Commit
                 .where(sha: pending_commits.map { |c| c[:sha] })
-                .pluck(:sha, :id).to_h
+                .select_hash(:sha, :id)
 
               if pending_branch_commits.any?
                 branch_commit_records = pending_branch_commits.map do |bc|
                   { branch_id: bc[:branch_id], commit_id: commit_ids[bc[:sha]], position: bc[:position] }
                 end
-                Models::BranchCommit.insert_all(branch_commit_records)
+                Models::BranchCommit.dataset.multi_insert(branch_commit_records)
               end
 
               if pending_changes.any?
-                manifest_ids = Models::Manifest.pluck(:path, :id).to_h
+                manifest_ids = Models::Manifest.select_hash(:path, :id)
                 change_records = pending_changes.map do |c|
                   {
                     commit_id: commit_ids[c[:sha]],
@@ -179,11 +178,11 @@ module Git
                     updated_at: now
                   }
                 end
-                Models::DependencyChange.insert_all(change_records)
+                Models::DependencyChange.dataset.multi_insert(change_records)
               end
 
               if pending_snapshots.any?
-                manifest_ids ||= Models::Manifest.pluck(:path, :id).to_h
+                manifest_ids ||= Models::Manifest.select_hash(:path, :id)
                 snapshot_records = pending_snapshots.map do |s|
                   {
                     commit_id: commit_ids[s[:sha]],
@@ -196,7 +195,7 @@ module Git
                     updated_at: now
                   }
                 end
-                Models::DependencySnapshot.insert_all(snapshot_records)
+                Models::DependencySnapshot.dataset.multi_insert(snapshot_records)
               end
             end
 

data/lib/git/pkgs/commands/diff.rb

@@ -38,22 +38,24 @@ module Git
 
           # Get all changes between the two commits
           changes = Models::DependencyChange
-            .includes(:commit, :manifest)
-            .joins(:commit)
-            .where("commits.committed_at > ? AND commits.committed_at <= ?",
-                   from_commit.committed_at, to_commit.committed_at)
-            .order("commits.committed_at ASC")
+            .eager(:commit, :manifest)
+            .join(:commits, id: :commit_id)
+            .where { Sequel[:commits][:committed_at] > from_commit.committed_at }
+            .where { Sequel[:commits][:committed_at] <= to_commit.committed_at }
+            .order(Sequel[:commits][:committed_at])
 
           if @options[:ecosystem]
-            changes = changes.where(ecosystem: @options[:ecosystem])
+            changes = changes.where(Sequel[:dependency_changes][:ecosystem] => @options[:ecosystem])
           end
 
-          if changes.empty?
+          changes_list = changes.all
+
+          if changes_list.empty?
             empty_result "No dependency changes between #{from_commit.short_sha} and #{to_commit.short_sha}"
             return
           end
 
-          paginate { output_text(from_commit, to_commit, changes) }
+          paginate { output_text(from_commit, to_commit, changes_list) }
         end
 
         def output_text(from_commit, to_commit, changes)

data/lib/git/pkgs/commands/history.rb

@@ -20,8 +20,8 @@ module Git
           Database.connect(repo.git_dir)
 
           changes = Models::DependencyChange
-            .includes(:commit, :manifest)
-            .order("commits.committed_at ASC")
+            .eager_graph(:commit, :manifest)
+            .order(Sequel[:commit][:committed_at])
 
           changes = changes.for_package(package_name) if package_name
 
@@ -31,32 +31,34 @@ module Git
 
           if @options[:author]
             author = @options[:author]
-            changes = changes.joins(:commit).where(
-              "commits.author_name LIKE ? OR commits.author_email LIKE ?",
-              "%#{author}%", "%#{author}%"
+            changes = changes.where(
+              Sequel.like(Sequel[:commit][:author_name], "%#{author}%") |
+              Sequel.like(Sequel[:commit][:author_email], "%#{author}%")
             )
           end
 
           if @options[:since]
             since_time = parse_time(@options[:since])
-            changes = changes.joins(:commit).where("commits.committed_at >= ?", since_time)
+            changes = changes.where { Sequel[:commit][:committed_at] >= since_time }
           end
 
           if @options[:until]
             until_time = parse_time(@options[:until])
-            changes = changes.joins(:commit).where("commits.committed_at <= ?", until_time)
+            changes = changes.where { Sequel[:commit][:committed_at] <= until_time }
           end
 
-          if changes.empty?
+          changes_list = changes.all
+
+          if changes_list.empty?
             msg = package_name ? "No history found for '#{package_name}'" : "No dependency changes found"
             empty_result msg
             return
           end
 
           if @options[:format] == "json"
-            output_json(changes)
+            output_json(changes_list)
           else
-            paginate { output_text(changes, package_name) }
+            paginate { output_text(changes_list, package_name) }
           end
         end
 

data/lib/git/pkgs/commands/hooks.rb

@@ -31,32 +31,32 @@ module Git
           end
         end
 
-        def install_hooks(repo)
+        def install_hooks(repo, quiet: false)
           hooks_dir = File.join(repo.git_dir, "hooks")
+          installed = []
 
           HOOKS.each do |hook_name|
             hook_path = File.join(hooks_dir, hook_name)
 
             if File.exist?(hook_path)
               content = File.read(hook_path)
-              if content.include?("git-pkgs")
-                info "Hook #{hook_name} already contains git-pkgs"
-                next
-              end
+              next if content.include?("git-pkgs")
 
               File.open(hook_path, "a") do |f|
                 f.puts "\n# git-pkgs auto-update"
                 f.puts "git pkgs update 2>/dev/null || true"
               end
-              info "Appended git-pkgs to existing #{hook_name} hook"
+              installed << hook_name
             else
               File.write(hook_path, HOOK_SCRIPT)
               File.chmod(0o755, hook_path)
-              info "Created #{hook_name} hook"
+              installed << hook_name
             end
           end
 
-          info "Hooks installed successfully"
+          return if quiet || installed.empty?
+
+          info "Installed hooks: #{installed.join(', ')}"
         end
 
         def uninstall_hooks(repo)

data/lib/git/pkgs/commands/info.rb

@@ -67,7 +67,7 @@ module Git
           puts "-" * 40
           total_dep_commits = Models::Commit.where(has_dependency_changes: true).count
           snapshot_commits = Models::Commit
-            .joins(:dependency_snapshots)
+            .join(:dependency_snapshots, commit_id: :id)
             .distinct
             .count
           puts "  Commits with dependency changes: #{total_dep_commits}"
@@ -102,8 +102,7 @@ module Git
 
           all_ecosystems.each do |eco|
             if Config.filter_ecosystem?(eco)
-              remote = Config.remote_ecosystem?(eco)
-              disabled_ecos << { name: eco, remote: remote }
+              disabled_ecos << eco
             else
               enabled_ecos << eco
             end
@@ -119,10 +118,7 @@ module Git
           puts
           puts "Disabled:"
           if disabled_ecos.any?
-            disabled_ecos.each do |eco|
-              suffix = eco[:remote] ? " (remote)" : ""
-              puts "  #{eco[:name]}#{suffix}"
-            end
+            disabled_ecos.each { |eco| puts "  #{eco}" }
           else
             puts "  (none)"
           end
@@ -131,9 +127,8 @@ module Git
           if filtering
             puts "Filtering: only #{configured.join(', ')}"
           else
-            puts "All local ecosystems enabled"
+            puts "All ecosystems enabled"
           end
-          puts "Remote ecosystems require explicit opt-in"
           puts "Configure with: git config --add pkgs.ecosystems <name>"
         end
 

data/lib/git/pkgs/commands/init.rb

@@ -41,34 +41,24 @@ module Git
           branch = Models::Branch.find_or_create(branch_name)
           analyzer = Analyzer.new(repo)
 
-          info "Analyzing branch: #{branch_name}"
+          print "Analyzing #{branch_name}..." unless Git::Pkgs.quiet
 
-          print "Loading commits..." unless Git::Pkgs.quiet
           walker = repo.walk(branch_name, @options[:since])
           commits = walker.to_a
           total = commits.size
-          print "\rPrefetching diffs..." unless Git::Pkgs.quiet
           repo.prefetch_blob_paths(commits)
-          print "\r#{' ' * 20}\r" unless Git::Pkgs.quiet
 
           stats = bulk_process_commits(commits, branch, analyzer, total)
 
           branch.update(last_analyzed_sha: repo.branch_target(branch_name))
 
-          print "\rCreating indexes...#{' ' * 20}" unless Git::Pkgs.quiet
           Database.create_bulk_indexes
           Database.optimize_for_reads
 
-          cache_stats = analyzer.cache_stats
-
-          info "\rDone!#{' ' * 20}"
-          info "Analyzed #{total} commits"
-          info "Found #{stats[:dependency_commits]} commits with dependency changes"
-          info "Stored #{stats[:snapshots_stored]} snapshots (every #{snapshot_interval} changes)"
-          info "Blob cache: #{cache_stats[:cached_blobs]} unique blobs, #{cache_stats[:blobs_with_hits]} had cache hits"
+          info "\r#{' ' * 40}\rAnalyzed #{branch_name}: #{total} commits (#{stats[:dependency_commits]} with dependency changes)"
 
           unless @options[:no_hooks]
-            Commands::Hooks.new(["--install"]).run
+            Commands::Hooks.new([]).install_hooks(repo, quiet: true)
           end
         end
 
@@ -90,22 +80,22 @@ module Git
           flush = lambda do
             return if pending_commits.empty?
 
-            ActiveRecord::Base.transaction do
-              Models::Commit.insert_all(pending_commits) if pending_commits.any?
+            Database.db.transaction do
+              Models::Commit.dataset.multi_insert(pending_commits) if pending_commits.any?
 
               commit_ids = Models::Commit
                 .where(sha: pending_commits.map { |c| c[:sha] })
-                .pluck(:sha, :id).to_h
+                .select_hash(:sha, :id)
 
               if pending_branch_commits.any?
                 branch_commit_records = pending_branch_commits.map do |bc|
                   { branch_id: bc[:branch_id], commit_id: commit_ids[bc[:sha]], position: bc[:position] }
                 end
-                Models::BranchCommit.insert_all(branch_commit_records)
+                Models::BranchCommit.dataset.multi_insert(branch_commit_records)
               end
 
               if pending_changes.any?
-                manifest_ids = Models::Manifest.pluck(:path, :id).to_h
+                manifest_ids = Models::Manifest.select_hash(:path, :id)
                 change_records = pending_changes.map do |c|
                   {
                     commit_id: commit_ids[c[:sha]],
@@ -120,11 +110,11 @@ module Git
                     updated_at: now
                   }
                 end
-                Models::DependencyChange.insert_all(change_records)
+                Models::DependencyChange.dataset.multi_insert(change_records)
               end
 
               if pending_snapshots.any?
-                manifest_ids ||= Models::Manifest.pluck(:path, :id).to_h
+                manifest_ids ||= Models::Manifest.select_hash(:path, :id)
                 snapshot_records = pending_snapshots.map do |s|
                   {
                     commit_id: commit_ids[s[:sha]],
@@ -137,7 +127,7 @@ module Git
                     updated_at: now
                   }
                 end
-                Models::DependencySnapshot.insert_all(snapshot_records)
+                Models::DependencySnapshot.dataset.multi_insert(snapshot_records)
               end
             end
 

data/lib/git/pkgs/commands/list.rb

@@ -18,7 +18,7 @@ module Git
           Database.connect(repo.git_dir)
 
           commit_sha = @options[:commit] || repo.head_sha
-          target_commit = Models::Commit.find_by(sha: commit_sha)
+          target_commit = Models::Commit.first(sha: commit_sha)
 
           error "Commit #{commit_sha[0, 7]} not in database. Run 'git pkgs update' to index new commits." unless target_commit
 
@@ -61,21 +61,21 @@ module Git
 
         def compute_dependencies_at_commit(target_commit, repo)
           branch_name = @options[:branch] || repo.default_branch
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
           return [] unless branch
 
           # Find the nearest snapshot commit before or at target
-          snapshot_commit = branch.commits
-            .joins(:dependency_snapshots)
-            .where("commits.committed_at <= ?", target_commit.committed_at)
-            .order(committed_at: :desc)
+          snapshot_commit = branch.commits_dataset
+            .join(:dependency_snapshots, commit_id: :id)
+            .where { Sequel[:commits][:committed_at] <= target_commit.committed_at }
+            .order(Sequel.desc(Sequel[:commits][:committed_at]))
             .distinct
             .first
 
           # Build initial state from snapshot
           deps = {}
           if snapshot_commit
-            snapshot_commit.dependency_snapshots.includes(:manifest).each do |s|
+            snapshot_commit.dependency_snapshots.each do |s|
               key = [s.manifest.path, s.name]
               deps[key] = {
                 manifest_path: s.manifest.path,
@@ -89,13 +89,15 @@ module Git
 
           # Replay changes from snapshot to target
           if snapshot_commit && snapshot_commit.id != target_commit.id
+            commit_ids = branch.commits_dataset.select_map(:id)
             changes = Models::DependencyChange
-              .joins(:commit)
-              .where(commits: { id: branch.commit_ids })
-              .where("commits.committed_at > ? AND commits.committed_at <= ?",
-                     snapshot_commit.committed_at, target_commit.committed_at)
-              .order("commits.committed_at ASC")
-              .includes(:manifest)
+              .join(:commits, id: :commit_id)
+              .where(Sequel[:commits][:id] => commit_ids)
+              .where { Sequel[:commits][:committed_at] > snapshot_commit.committed_at }
+              .where { Sequel[:commits][:committed_at] <= target_commit.committed_at }
+              .order(Sequel[:commits][:committed_at])
+              .eager(:manifest)
+              .all
 
             changes.each do |change|
               key = [change.manifest.path, change.name]

data/lib/git/pkgs/commands/log.rb

@@ -18,16 +18,22 @@ module Git
           Database.connect(repo.git_dir)
 
           commits = Models::Commit
-            .includes(:dependency_changes)
+            .eager(:dependency_changes)
             .where(has_dependency_changes: true)
-            .order(committed_at: :desc)
+            .order(Sequel.desc(:committed_at), Sequel.desc(:id))
+
+          if @options[:author]
+            author = @options[:author]
+            commits = commits.where(
+              Sequel.like(:author_name, "%#{author}%") |
+              Sequel.like(:author_email, "%#{author}%")
+            )
+          end
 
-          commits = commits.where("author_name LIKE ? OR author_email LIKE ?",
-            "%#{@options[:author]}%", "%#{@options[:author]}%") if @options[:author]
-          commits = commits.where("committed_at >= ?", parse_time(@options[:since])) if @options[:since]
-          commits = commits.where("committed_at <= ?", parse_time(@options[:until])) if @options[:until]
+          commits = commits.where { committed_at >= parse_time(@options[:since]) } if @options[:since]
+          commits = commits.where { committed_at <= parse_time(@options[:until]) } if @options[:until]
 
-          commits = commits.limit(@options[:limit] || 20)
+          commits = commits.limit(@options[:limit] || 20).all
 
           if commits.empty?
             empty_result "No commits with dependency changes found"

data/lib/git/pkgs/commands/schema.rb

@@ -33,32 +33,29 @@ module Git
         end
 
         def fetch_schema
-          conn = ActiveRecord::Base.connection
+          db = Database.db
           tables = {}
 
-          conn.tables.sort.each do |table_name|
-            next if table_name == "ar_internal_metadata"
-            next if table_name == "schema_migrations"
-
-            columns = conn.columns(table_name).map do |col|
+          db.tables.sort.each do |table_name|
+            columns = db.schema(table_name).map do |name, col_info|
               {
-                name: col.name,
-                type: col.type,
-                sql_type: col.sql_type,
-                null: col.null,
-                default: col.default
+                name: name.to_s,
+                type: col_info[:type],
+                sql_type: col_info[:db_type],
+                null: col_info[:allow_null],
+                default: col_info[:default]
               }
             end
 
-            indexes = conn.indexes(table_name).map do |idx|
+            indexes = db.indexes(table_name).map do |name, idx_info|
               {
-                name: idx.name,
-                columns: idx.columns,
-                unique: idx.unique
+                name: name.to_s,
+                columns: idx_info[:columns].map(&:to_s),
+                unique: idx_info[:unique]
               }
             end
 
-            tables[table_name] = { columns: columns, indexes: indexes }
+            tables[table_name.to_s] = { columns: columns, indexes: indexes }
           end
 
           tables
@@ -72,7 +69,7 @@ module Git
             info[:columns].each do |col|
               nullable = col[:null] ? "NULL" : "NOT NULL"
               default = col[:default] ? " DEFAULT #{col[:default]}" : ""
-              puts "  #{col[:name].ljust(25)} #{col[:sql_type].ljust(15)} #{nullable}#{default}"
+              puts "  #{col[:name].ljust(25)} #{col[:sql_type].to_s.ljust(15)} #{nullable}#{default}"
             end
 
             if info[:indexes].any?
@@ -89,16 +86,16 @@ module Git
         end
 
         def output_sql(tables)
-          conn = ActiveRecord::Base.connection
+          db = Database.db
 
           tables.each do |table_name, info|
-            sql = conn.execute("SELECT sql FROM sqlite_master WHERE type='table' AND name='#{table_name}'").first
-            puts sql["sql"] + ";" if sql
+            sql = db.fetch("SELECT sql FROM sqlite_master WHERE type='table' AND name=?", table_name).first
+            puts sql[:sql] + ";" if sql
             puts
 
             info[:indexes].each do |idx|
-              idx_sql = conn.execute("SELECT sql FROM sqlite_master WHERE type='index' AND name='#{idx[:name]}'").first
-              puts idx_sql["sql"] + ";" if idx_sql && idx_sql["sql"]
+              idx_sql = db.fetch("SELECT sql FROM sqlite_master WHERE type='index' AND name=?", idx[:name]).first
+              puts idx_sql[:sql] + ";" if idx_sql && idx_sql[:sql]
             end
 
             puts if info[:indexes].any?