pg_reindex 0.1.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.swp
+.bundle
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    pg_reindex (0.1.1)
+      pg
+      thor
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.5)
+      activesupport (= 3.2.5)
+      builder (~> 3.0.0)
+    activerecord (3.2.5)
+      activemodel (= 3.2.5)
+      activesupport (= 3.2.5)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.5)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    multi_json (1.3.6)
+    pg (0.13.2)
+    rake (0.9.2.2)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    thor (0.15.2)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  pg_reindex!
+  rake
+  rspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Makarchev K
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+Pg Reindex
+==========
+
+Console utility for gracefully rebuild indexes/pkeys for PostgreSQL, with minimal locking in semi-auto mode.
+
+Install:
+
+    $ gem install pg_reindex
+  
+Using:
+
+    export PGRE_CFG=/some/path/database.yml 
+    pgre --help
+
+User in connection should be an owner of relations. And for rebuild pkey, should be superuser.
+
+Tasks:
+
+    pgre dbs                                        # Show list of databases from database.yml
+    pgre install ENV                                # Install function swap_for_pkey to database
+    pgre rebuild ENV (table|index)[,(table|index)]  # rebuild tables,indexes,pkeys
+    pgre tables ENV                                 # Show tables of database
+
+Examples:
+
+    # Show tables with indexes, which full size more than 1Gb
+    pgre tables production -s 1000
+
+    # Show process without really rebuild
+    pgre rebuild production users,some_index1,some_index2
+  
+    # Rebuild indexes 
+    pgre rebuild production users --write
+    
+    # Rebuild indexes and no ask confirmation (not recommended)
+    pgre rebuild production users --write --no-ask  
+
+
+Explanation/Warning:
+--------------------
+
+Rebuild index produces sqls:
+    
+    1. CREATE INDEX CONCURRENTLY bla2 on some_table USING btree (some_field);
+    2. ANALYZE some_table;
+    3. DROP INDEX bla;
+    4. ALTER INDEX bla2 RENAME TO bla; 
+    
+  2 can be blocked by long running query(LRQ), or autovacuum (in this case just kill autovacuum or wait LRQ).
+  By careful, if between 2 and (3,4) started LRQ or autovacuum, (3,4) can blocks all queries on this table. If this happens, and (3,4) not quit after < 30s, should stop (3,4) by cancel query in PostgreSQL. And execute (3,4) manually.
+  
+  
+Rebuild pkey produces sqls:
+  
+    1. CREATE UNIQUE INDEX CONCURRENTLY some_table_pkey2 on some_table USING btree (ID);
+    2. ANALYZE some_table;
+    3. SELECT swap_for_pkey('public', 'some_table_pkey', 'some_table_pkey2');
+
+  Same issue with 2 and 3.
+
+
+
+MIT-LICENCE

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new(:spec)

data/bin/pgre

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+require 'yaml'
+require File.dirname(__FILE__) + '/../lib/pg-reindex'
+
+class PgReindexer < Thor
+
+  desc "dbs", "Show list of databases from database.yml (-n if no show sizes)"
+  method_option :no_size, :aliases => '-n', :type => :boolean
+  def dbs    
+    list = db_list(!options[:no_size])
+    return unless list
+    
+    render_db_list(list)
+  end
+
+  desc "tables ENV", "Show tables of database"
+  method_option :size, :aliases => '-s', :type => :string
+  def tables(env)
+    conn = get_connection(env)
+    relations = conn.get_struct_relations(options[:size])
+    render_tables(env, relations)
+  end
+  
+  desc "rebuild ENV (table|index)[,(table|index)]", "rebuild tables,indexes,pkeys"
+  method_option :write, :aliases => '--write', :type => :boolean
+  method_option :no_ask, :aliases => '--no-ask', :type => :boolean
+  def rebuild(env, to_reindex = '')
+    if !to_reindex || to_reindex.empty?
+      say "blank attributes to rebuild", :red
+      exit 1
+    end
+
+    conn = get_connection(env)
+    
+    rebuild = conn.filter_relations(to_reindex)
+   
+    rebuild.each do |row|
+      do_rebuild conn, row, options[:write], !options[:no_ask]
+    end
+    
+    if rebuild.empty?
+      say "nothing to rebuild", :red
+    end
+  end
+  
+  desc "install ENV", "Install need function to database, like function: swap_for_pkey"
+  def install(env)
+    conn = get_connection(env)
+    conn.install_swap_for_pkey
+    say "DONE!", :green
+  end
+  
+  desc "queries ENV", "Show current queries on database ENV"
+  def queries(env)
+    conn = get_connection(env)
+    q = conn.queries
+    r = q.map do |query|
+      [query['procpid'], query['age'], query['current_query']]
+    end
+    
+    print_table r
+  end
+  
+  desc "cancel ENV PID", "Cancel pid query"
+  def cancel(env, pid)
+    conn = get_connection(env)
+    conn.cancel(pid)
+  end
+  
+private
+
+  def get_connection(env)
+    conn = connection(env)
+    unless conn
+      say "Not connected to #{env}, hm!!!", :red
+      exit 1
+    end
+    
+    conn
+  end
+
+  def connection(env)
+    cn = connect(env, db_config[env])
+  end
+
+  def connect(env, conf)
+    @connects ||= {}
+    @connects[env] ||= PgReindex.new(conf) if conf
+  end
+  
+  # load database.yml
+  def db_config
+    @db_config ||= begin
+      file = ENV['PGRE_CFG'] || `pwd`.to_s.chop + "/config/database.yml"
+      if File.exists?(file)
+        YAML.load_file(file)
+      else
+        say "Specify path to database.yml with env CFG, like: CFG=/../../database.yml", :red
+        exit 1
+      end
+    end
+  end   
+  
+  def db_list(show_sizes = true)
+    cfg = db_config
+    return unless cfg
+            
+    cfg = cfg.sort_by{|a| a[0]}
+    cfg.map do |env, config|
+      x = [env, config]
+      x << (connection(env).database_size(config['database']) rescue '-') if show_sizes
+      x
+    end
+  end
+                                            
+  def do_rebuild(conn, row, write = true, ask = true)
+    #ask = false unless write
+    
+    say "=> rebuild #{row['index']} (#{row['i_size_p']}), write #{write}, ask #{ask}", :yellow
+    
+    sqls = conn.index_sqls(row)
+    
+    if ask || !write
+      sqls.each do |sql|
+        say "  #{sql}"
+      end
+    end
+    
+    if ask
+      r = ask_until("Rebuild? (y/n)")
+      if r == '' || r == 'y' || r == 'Y'
+      else
+        say "  ... skipped\n", :red
+        return      
+      end
+    end
+    
+    if row['index'].end_with?("_pkey")
+      unless conn.check_swap_for_pkey
+        say "  ... You should install function swap_for_pkey for rebuild pkey, call: #{$0} install ENV", :red
+        return
+      end
+    end
+    
+    started_at = Time.now
+    
+    if write
+      sqls.each do |query|
+        say "  => ", :bold, false
+        say "#{query}", nil, false
+        tm = Time.now
+      
+        conn.exec(query)
+      
+        say " (#{"%.3f" % (Time.now - tm)}s)"
+      end
+      
+      new_size = conn.get_index_size(row['index'])['i_size_p'] rescue '-'
+      say "<= rebuilded #{row['index']} (#{new_size})", :yellow
+      say "  DONE! (#{"%.3f" % (Time.now - started_at)}s)\n", :green
+    else
+      say "  DRY-RUN DONE\n", :green
+    end
+  end
+  
+  def render_db_list(db_list)
+    say "Databases list:", :green
+    db_list.each do |row|
+      say "\t#{row[0].ljust(30)} ", :yellow, false
+      say "#{row[1]['database']}:#{row[1]['host']}".ljust(60)
+      say "#{row[2]}"
+    end
+  end
+  
+  def render_tables(env, relations)
+    off1 = 65
+    off2 = 15
+    off3 = 15
+
+    say "tables for #{env.ljust(off1 - 9)}size#{''.ljust(off2 - 4)}indexes_size", :green
+    
+    relations.each do |table, indexes|
+      say "  #{table.ljust(off1)}", :yellow, false
+      f = indexes[0]
+      say "#{f['size_p'].ljust(off2)}", :yellow, false
+      say "#{f['total_i_size_p'].ljust(off3)}", :yellow, true
+      #say "#{f['total_size_p']}", :yellow
+
+        
+      indexes.each do |rel|
+        say "    #{(rel['index']+" ").ljust(off1 - 2 + off2, '.')}", nil, false
+        say "#{rel['i_size_p']}"
+      end
+    end
+  end
+  
+  def ask_until(str, answers = ['y', 'n', ''])
+    loop do
+      res = ask(str)
+      return res if answers.include?(res)
+    end    
+  end
+  
+end
+
+PgReindexer.start

data/lib/pg-reindex.rb

@@ -0,0 +1,193 @@
+require 'pg'
+
+class PgReindex
+
+  MIN_SIZE = 50 # megabyte min, total table size
+
+  def initialize(conf)
+    cfg = {:host => conf['host'] || '127.0.0.1', :dbname => conf['database'],
+           :user => conf['username'] || `whoami`.chop, :password => conf['password'] || 'password', :port => conf['port'].to_s}
+
+    @conn = PGconn.new cfg
+  end
+  
+  def get_struct_relations(min_size = nil)
+    res = get_raw_relations
+ 
+    result = {}
+    res.each do |row|
+      next if row['total_size'].to_i < ((min_size || MIN_SIZE).to_f * 1024 * 1024).to_i
+      result[row['table']] ||= []
+      result[row['table']] << row
+    end
+ 
+    result = result.sort_by{|el| el[1][0]['total_size'].to_i}.reverse
+     
+    result = result.map do |table, res|
+      [table, res]
+    end
+    
+    result
+  end
+  
+  def filter_relations(filter) # filter is a string with ,
+    return [] if !filter || filter.empty?
+    
+    filter = filter.split(",")
+
+    get_raw_relations.select do |row|
+      filter.include?(row['index']) || filter.include?(row['table'])
+    end
+  end
+  
+  def get_raw_relations
+    res = @conn.exec <<-SQL
+      SELECT C.relname AS "table",
+        i.relname "index",
+        i.oid "index_oid",
+        pg_relation_size(C.oid) AS "size",
+        pg_total_relation_size(C.oid) AS "total_size",
+        pg_size_pretty(pg_relation_size(C.oid)) AS "size_p",
+        pg_size_pretty(pg_total_relation_size(C.oid)) AS "total_size_p",
+        pg_size_pretty(pg_total_relation_size(C.oid) - pg_relation_size(C.oid)) AS "total_i_size_p",
+        pg_relation_size(i.oid) as "i_size",
+        pg_size_pretty(pg_relation_size(i.oid)) as "i_size_p"
+      FROM pg_class C, pg_class i, pg_index ix, pg_namespace N
+      WHERE nspname IN ('public') AND
+              C.oid = ix.indrelid and i.oid = ix.indexrelid
+              AND C.oid = ix.indrelid and i.oid = ix.indexrelid
+              AND C.relname not like 'pg_%'
+              AND N.oid = C.relnamespace
+      ORDER BY c.relname, i.relname
+    SQL
+  end
+  
+  def get_index_size(relation_name)
+    res = @conn.exec "SELECT pg_relation_size(oid) as i_size, pg_size_pretty(pg_relation_size(oid)) as i_size_p 
+                        from pg_class WHERE relname = E'#{relation_name}'"
+    res[0]
+  rescue 
+    {}
+  end
+  
+  def install_swap_for_pkey
+    @conn.exec("create language plpgsql") rescue nil
+    @conn.exec(swap_for_pkey_sql)
+  end
+  
+  def check_swap_for_pkey
+    res = @conn.exec <<-SQL
+      SELECT  proname FROM pg_catalog.pg_namespace n JOIN pg_catalog.pg_proc p ON pronamespace = n.oid
+      WHERE   nspname = 'public' and proname = 'swap_for_pkey'
+    SQL
+    
+    res.values.size == 1
+  end
+  
+  def swap_for_pkey_sql
+    <<-SQL
+CREATE OR REPLACE FUNCTION swap_for_pkey(text,text,text) returns integer
+AS  
+$$  
+   DECLARE  
+     cmd text;  
+     oid1 integer;  
+     oid2 integer;  
+     filenode1 integer;  
+     filenode2 integer;  
+     relation text;  
+   BEGIN  
+      select oid::integer into oid1 from pg_class where relname=$2 and relnamespace = (select oid from pg_namespace where nspname=$1);  
+     RAISE NOTICE 'PKEY OID: %',oid1;  
+      select relfilenode::integer into filenode1 from pg_class where oid=oid1;  
+      select oid::integer into oid2 from pg_class where relname=$3 and relnamespace = (select oid from pg_namespace where nspname=$1);  
+     RAISE NOTICE 'PKEY OID: %',oid2;  
+      select relfilenode::integer into filenode2 from pg_class where oid=oid2;  
+      select (indrelid::regclass)::text into relation from pg_index where indexrelid=oid1;  
+    RAISE NOTICE 'RELATION NAME: %',relation;  
+      cmd:='LOCK '||relation||';';  
+      RAISE NOTICE 'Executing :- %',cmd;  
+      Execute cmd;        
+      cmd:='UPDATE pg_class SET relfilenode='||filenode2|| ' WHERE oid='||oid1||';';  
+      RAISE NOTICE 'Executing :- %',cmd;  
+      Execute cmd;        
+      cmd:='UPDATE pg_class SET relfilenode='||filenode1|| ' WHERE oid='||oid2||';';  
+      RAISE NOTICE 'Executing :- %',cmd;  
+      Execute cmd;  
+      cmd:='DROP INDEX '||$1||'.'||$3||';';  
+      RAISE NOTICE 'Executing :- %',cmd;  
+      Execute cmd;  
+      return 0;  
+   END;  
+$$language plpgsql;  
+    SQL
+  end
+  
+  def database_size(database)
+    res = @conn.exec("SELECT pg_size_pretty(pg_database_size('#{database}')) as db_size")
+    res.first['db_size']
+  end
+
+  def index_sqls(index_row)
+    index_sql_array(index_row['table'], index_row['index_oid'], index_row['index'])
+  end
+    
+  def index_sql_array(table, oid, name)
+    new_name = if name.size < 61  
+      name + "_2"
+    else
+      name[0..-3] + "_2"
+    end
+    
+    if name.end_with?('_pkey')
+      [
+        index_sql(table, oid, name, new_name),
+        "ANALYZE #{table}",
+        "SELECT swap_for_pkey('public', '#{name}', '#{new_name}')"
+      ]
+    else
+      [
+        index_sql(table, oid, name, new_name),
+        "ANALYZE #{table}",
+        "DROP INDEX #{name}",
+        "ALTER INDEX #{new_name} RENAME TO #{name}"
+      ]
+    end
+  end
+    
+  def index_sql(table, oid, name, new_name)
+    str = index_def(oid).gsub(name, new_name)
+    
+    pos = str.index(new_name)
+            
+    before = str[0..pos-2]
+    after = str[pos..-1]
+                       
+    "#{before} CONCURRENTLY #{after}"
+  end
+  
+  def index_def(oid)
+    sql = "SELECT pg_get_indexdef(#{oid}) as q"
+    exec(sql)[0]['q']
+  end
+  
+  def exec(sql)
+    @conn.exec sql
+  end
+  
+  def queries
+    @conn.exec <<-SQL
+    SELECT procpid,  now() - query_start as age, current_query
+    FROM
+        pg_stat_activity AS a JOIN
+        pg_locks AS l ON a.procpid = l.pid
+    WHERE 
+        virtualxid IS NOT NULL order by age desc;
+    SQL
+  end
+  
+  def cancel(procpid)
+    @conn.exec "select pg_cancel_backend(#{procpid.to_i})"
+  end
+
+end

data/pg_reindex.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pg_reindex}
+  s.version = "0.1.1"
+
+  s.authors = ["Makarchev Konstantin"]
+ 
+  s.description = %q{Console utility for gracefully rebuild indexes/pkeys for PostgreSQL, with minimal locking in semi-auto mode.}
+  s.summary = %q{Console utility for gracefully rebuild indexes/pkeys for PostgreSQL, with minimal locking in semi-auto mode.}
+
+  s.email = %q{kostya27@gmail.com}
+  s.homepage = %q{http://github.com/kostya/pg_reindex}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'thor'
+  s.add_dependency 'pg'
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency 'activerecord'
+  
+end

data/spec/reindex_spec.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe PgReindex do
+  before :each do
+    @pgre = PgReindex.new($cfg)
+  end
+  
+  def row(name)
+    @pgre.filter_relations(name).first
+  end  
+
+  it "get_raw_relations" do
+    res = @pgre.get_raw_relations
+    v = []
+    res.each{|h| v << h }
+    
+    v.map{|el| el['table']}.uniq.should == ['tests']
+    v.map{|el| el['index']}.uniq.sort.should == ["a_b_c", "index_tests_on_a", "index_tests_on_b_and_c", "tests_pkey"]
+    v.map{|el| el['index_oid']}.sum.to_i.should > 0
+  end
+  
+  describe "filter_relations" do
+    it "1" do
+      res = @pgre.filter_relations('a_b_c')
+      res.size.should == 1
+      res[0]['index'].should == 'a_b_c'
+    end
+    
+    it "2" do 
+      res = @pgre.filter_relations('a_b_c,index_tests_on_a,tests_pkey,xxx')
+      res.size.should == 3
+      res.map{|el| el['index']}.sort.should == ["a_b_c", "index_tests_on_a", "tests_pkey"]
+    end
+    
+    it "3" do
+      res = @pgre.filter_relations('tests,xxx')
+      res.size.should == 4
+      res.map{|el| el['index']}.sort.should == ["a_b_c", "index_tests_on_a", "index_tests_on_b_and_c", "tests_pkey"]
+    end
+    
+    it "4" do
+      res = @pgre.filter_relations('xxx')
+      res.size.should == 0
+    end
+    
+    it "5" do
+      res = @pgre.filter_relations('tests,a_b_c')
+      res.size.should == 4
+      res.map{|el| el['index']}.sort.should == ["a_b_c", "index_tests_on_a", "index_tests_on_b_and_c", "tests_pkey"]
+    end                
+  end
+  
+  it "database_size" do
+    s = @pgre.database_size('pgre_test')
+    s.to_i.should > 1
+  end
+  
+  describe "index sqls" do
+    it "index sqls for a" do
+      @pgre.index_sqls(row('index_tests_on_a')).should == ["CREATE INDEX CONCURRENTLY index_tests_on_a_2 ON tests USING btree (a)", 
+        "ANALYZE tests", "DROP INDEX index_tests_on_a", "ALTER INDEX index_tests_on_a_2 RENAME TO index_tests_on_a"]
+    end
+  
+    it "index sqls for b,c" do
+      @pgre.index_sqls(row('index_tests_on_b_and_c')).should == ["CREATE INDEX CONCURRENTLY index_tests_on_b_and_c_2 ON tests USING btree (b, c)", 
+        "ANALYZE tests", "DROP INDEX index_tests_on_b_and_c", "ALTER INDEX index_tests_on_b_and_c_2 RENAME TO index_tests_on_b_and_c"]
+    end
+  
+    it "index sqls for a,b,c" do
+      @pgre.index_sqls(row('a_b_c')).should == ["CREATE UNIQUE INDEX CONCURRENTLY a_b_c_2 ON tests USING btree (a, b, c) WHERE ((a > 0) AND (b < 0))", 
+        "ANALYZE tests", "DROP INDEX a_b_c", "ALTER INDEX a_b_c_2 RENAME TO a_b_c"]
+    end
+  
+    it "index sqls for pkey" do
+      @pgre.index_sqls(row('tests_pkey')).should == ["CREATE UNIQUE INDEX CONCURRENTLY tests_pkey_2 ON tests USING btree (id)", 
+        "ANALYZE tests", "SELECT swap_for_pkey('public', 'tests_pkey', 'tests_pkey_2')"] 
+    end
+  end
+  
+  it "index def" do
+    r = row('a_b_c')
+    @pgre.index_def(r['index_oid']).should == "CREATE UNIQUE INDEX a_b_c ON tests USING btree (a, b, c) WHERE ((a > 0) AND (b < 0))"
+  end
+  
+  it "rebuilds index" do
+    r = row('a_b_c')
+    r['index_oid'].to_i.should > 0
+    def1 = @pgre.index_def(r['index_oid'])
+    
+    sqls = @pgre.index_sqls(r)
+    sqls.each do |sql|
+      @pgre.exec sql
+    end
+    
+    r2 = row('a_b_c')
+    r2['index_oid'].to_i.should > 0
+    
+    r2['index_oid'].should_not == r['index_oid']
+    r2['index'].should == r['index']
+    
+    def2 = @pgre.index_def(r2['index_oid'])
+    def1.should == def2
+    
+    # index should be
+    res = @pgre.filter_relations('tests')
+    res.size.should == 4
+    res.map{|el| el['index']}.sort.should == ["a_b_c", "index_tests_on_a", "index_tests_on_b_and_c", "tests_pkey"]    
+  end
+  
+  it "rebuilds pkey" do
+    # install swap_for_pkey
+    @pgre.install_swap_for_pkey
+  
+    r = row('tests_pkey')
+    r['index_oid'].to_i.should > 0
+    def1 = @pgre.index_def(r['index_oid'])
+        
+    sqls = @pgre.index_sqls(r)
+    sqls.each do |sql|
+      @pgre.exec sql
+    end
+                          
+    r2 = row('tests_pkey')
+    r2['index_oid'].to_i.should > 0
+
+    r2['index_oid'].should == r['index_oid']
+    def1.should == @pgre.index_def(r2['index_oid'])
+                                      
+    # index should be
+    res = @pgre.filter_relations('tests')
+    res.size.should == 4
+    res.map{|el| el['index']}.sort.should == ["a_b_c", "index_tests_on_a", "index_tests_on_b_and_c", "tests_pkey"]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require "bundler"
+Bundler.setup
+ENV['RAILS_ENV'] ||= 'test'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'pg-reindex'
+
+require 'active_record'
+
+require File.dirname(__FILE__) + '/spec_support.rb'

data/spec/spec_support.rb

@@ -0,0 +1,25 @@
+$cfg = {'adapter' => 'postgresql', 'database' => 'pgre_test', 'encoding' => 'utf8', 'username' => 'kostya', 'password' => 'password'}
+ActiveRecord::Base.establish_connection $cfg
+
+class Test < ActiveRecord::Base
+  self.table_name = 'tests'
+end
+
+def pg_create_schema
+  ActiveRecord::Migration.create_table :tests do |t|
+    t.integer :a
+    t.integer :b
+    t.integer :c
+  end
+  
+  ActiveRecord::Migration.add_index :tests, :a
+  ActiveRecord::Migration.add_index :tests, [:b, :c]
+  ActiveRecord::Migration.execute "create unique index a_b_c on tests using btree(a,b,c) where a > 0 and b < 0"
+end
+
+def pg_drop_data
+  ActiveRecord::Migration.drop_table :tests
+end
+
+pg_drop_data rescue nil
+pg_create_schema

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: pg_reindex
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Makarchev Konstantin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Console utility for gracefully rebuild indexes/pkeys for PostgreSQL, with minimal locking in semi-auto mode.
+email: kostya27@gmail.com
+executables: 
+- pgre
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/pgre
+- lib/pg-reindex.rb
+- pg_reindex.gemspec
+- spec/reindex_spec.rb
+- spec/spec_helper.rb
+- spec/spec_support.rb
+homepage: http://github.com/kostya/pg_reindex
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Console utility for gracefully rebuild indexes/pkeys for PostgreSQL, with minimal locking in semi-auto mode.
+test_files: []
+