schema_plus_pg_indexes 0.1.0

data/lib/schema_plus_pg_indexes/version.rb

@@ -0,0 +1,3 @@
+module SchemaPlusPgIndexes
+  VERSION = "0.1.0"
+end

data/schema_dev.yml

@@ -0,0 +1,7 @@
+ruby:
+    - 1.9.3
+    - 2.1.5
+rails:
+    - 4.2
+db:
+    - postgresql

data/schema_plus_pg_indexes.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schema_plus_pg_indexes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "schema_plus_pg_indexes"
+  spec.version       = SchemaPlusPgIndexes::VERSION
+  spec.authors       = ["ronen barzel"]
+  spec.email         = ["ronen@barzel.org"]
+  spec.summary       = %q{Adds support in ActiveRecord for PostgreSQL index expressions and operator classes, as well as a shorthand for case-insensitive indexes}
+  spec.homepage      = "https://github.com/SchemaPlus/schema_plus_pg_indexes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 4.2"
+  spec.add_dependency "schema_monkey", "~> 0.3"
+  spec.add_dependency "schema_plus_indexes", "~> 0.1"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "schema_dev", "~> 2.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-gem-profile"
+end

data/spec/deprecation_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe 'Deprecations' do
+
+  before(:all) do
+      class User < ::ActiveRecord::Base ; end
+  end
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  context "on table creation" do
+    it "deprecates :conditions" do
+      where = "((login)::text ~~ '%xyz'::text)"
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/conditions.*where/)
+      create_table User, :login => { index: { conditions: where } }
+      index = User.indexes.first
+      expect(index.where).to eq where
+    end
+
+    it "deprecates :kind" do
+      using = :hash
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/kind.*using/)
+      create_table User, :login => { index: { kind: using } }
+      index = User.indexes.first
+      expect(index.using).to eq using
+    end
+  end
+
+  context "on IndexDefinition object" do
+
+    it "deprecates #conditions" do
+      where = "((login)::text ~~ '%xyz'::text)"
+      create_table User, :login => { index: { where: where } }
+      index = User.indexes.first
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/conditions.*where/)
+      expect(index.where).to eq where # sanity check
+      expect(index.conditions).to eq index.where
+    end
+
+    it "deprecates #kind" do
+      using = :hash
+      create_table User, :login => { index: { using: using } }
+      index = User.indexes.first
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/kind.*using/)
+      expect(index.using).to eq using # sanity check
+      expect(index.kind).to eq index.using
+    end
+  end
+
+  protected
+
+  def create_table(model, columns_with_options)
+    migration.suppress_messages do
+      migration.create_table model.table_name, :force => true do |t|
+        columns_with_options.each_pair do |column, options|
+          t.send :string, column, options
+        end
+      end
+      model.reset_column_information
+    end
+  end
+end

data/spec/index_definition_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+
+describe "Index definition" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  before(:all) do
+    define_schema do
+      create_table :users, :force => true do |t|
+        t.string :login
+        t.datetime :deleted_at
+      end
+
+      create_table :posts, :force => true do |t|
+        t.text :body
+        t.integer :user_id
+        t.integer :author_id
+      end
+
+    end
+    class User < ::ActiveRecord::Base ; end
+    class Post < ::ActiveRecord::Base ; end
+  end
+
+  around(:each) do |example|
+    migration.suppress_messages do
+      example.run
+    end
+  end
+
+  after(:each) do
+    migration.remove_index :users, :name => 'users_login_index' if migration.index_name_exists? :users, 'users_login_index', true
+  end
+
+  context "when case insensitive is added" do
+
+    before(:each) do
+      migration.execute "CREATE INDEX users_login_index ON users(LOWER(login))"
+      User.reset_column_information
+      @index = User.indexes.detect { |i| i.expression =~ /lower\(\(login\)::text\)/i }
+    end
+
+    it "is included in User.indexes" do
+      expect(@index).not_to be_nil
+    end
+
+    it "is not case_sensitive" do
+      expect(@index).not_to be_case_sensitive
+    end
+
+    it "defines expression" do
+      expect(@index.expression).to eq("lower((login)::text)")
+    end
+
+    it "doesn't define where" do
+      expect(@index.where).to be_nil
+    end
+
+  end
+
+
+  context "when index contains expression" do
+    before(:each) do
+      migration.execute "CREATE INDEX users_login_index ON users (extract(EPOCH from deleted_at)) WHERE deleted_at IS NULL"
+      User.reset_column_information
+      @index = User.indexes.detect { |i| i.expression.present? }
+    end
+
+    it "exists" do
+      expect(@index).not_to be_nil
+    end
+
+    it "doesnt have columns defined" do
+      expect(@index.columns).to be_empty
+    end
+
+    it "is case_sensitive" do
+      expect(@index).to be_case_sensitive
+    end
+
+    it "defines expression" do
+      expect(@index.expression).to eq("date_part('epoch'::text, deleted_at)")
+    end
+
+    it "defines where" do
+      expect(@index.where).to eq("(deleted_at IS NULL)")
+    end
+
+  end
+
+  context "when index has a non-btree type" do
+    before(:each) do
+      migration.execute "CREATE INDEX users_login_index ON users USING hash(login)"
+      User.reset_column_information
+      @index = User.indexes.detect { |i| i.name == "users_login_index" }
+    end
+
+    it "exists" do
+      expect(@index).not_to be_nil
+    end
+
+    it "defines using" do
+      expect(@index.using).to eq(:hash)
+    end
+
+    it "does not define expression" do
+      expect(@index.expression).to be_nil
+    end
+
+    it "does not define order" do
+      expect(@index.orders).to be_blank
+    end
+  end
+
+  context "equality" do
+
+    it "returns true when case sensitivity are the same" do
+      expect(ActiveRecord::ConnectionAdapters::IndexDefinition.new("table", "column", case_sensitive: true)).to eq ActiveRecord::ConnectionAdapters::IndexDefinition.new("table", "column", case_sensitive: true)
+    end
+
+    it "returns false when case sensitivity are the different" do
+      expect(ActiveRecord::ConnectionAdapters::IndexDefinition.new("table", "column", case_sensitive: true)).not_to eq ActiveRecord::ConnectionAdapters::IndexDefinition.new("table", "column", case_sensitive: false)
+    end
+
+  end
+
+
+  protected
+  def index_definition(column_names)
+    User.indexes.detect { |index| index.columns == Array(column_names) }
+  end
+
+
+end

data/spec/index_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe "index" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+  let(:connection) { ::ActiveRecord::Base.connection }
+
+  describe "add_index" do
+
+    before(:each) do
+      connection.tables.each do |table| connection.drop_table table, cascade: true end
+
+      define_schema do
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.text :address
+          t.datetime :deleted_at
+        end
+
+        create_table :posts, :force => true do |t|
+          t.text :body
+          t.integer :user_id
+          t.integer :author_id
+        end
+
+      end
+      class User < ::ActiveRecord::Base ; end
+      class Post < ::ActiveRecord::Base ; end
+    end
+
+
+    after(:each) do
+      migration.suppress_messages do
+        migration.remove_index(:users, :name => @index.name) if (@index ||= nil)
+      end
+    end
+
+    context "extra features" do
+
+      it "should assign expression, where and using" do
+        add_index(:users, :expression => "USING hash (upper(login)) WHERE deleted_at IS NULL", :name => 'users_login_index')
+        @index = User.indexes.detect { |i| i.expression.present? }
+        expect(@index.expression).to eq("upper((login)::text)")
+        expect(@index.where).to eq("(deleted_at IS NULL)")
+        expect(@index.using).to       eq(:hash)
+      end
+
+      it "should allow to specify expression, where and using separately" do
+        add_index(:users, :using => "hash", :expression => "upper(login)", :where => "deleted_at IS NULL", :name => 'users_login_index')
+        @index = User.indexes.detect { |i| i.expression.present? }
+        expect(@index.expression).to eq("upper((login)::text)")
+        expect(@index.where).to eq("(deleted_at IS NULL)")
+        expect(@index.using).to eq(:hash)
+      end
+
+      it "should assign operator_class" do
+        add_index(:users, :login, :operator_class => 'varchar_pattern_ops')
+        expect(index_for(:login).operator_classes).to eq({"login" => 'varchar_pattern_ops'})
+      end
+
+      it "should assign multiple operator_classes" do
+        add_index(:users, [:login, :address], :operator_class => {:login => 'varchar_pattern_ops', :address => 'text_pattern_ops'})
+        expect(index_for([:login, :address]).operator_classes).to eq({"login" => 'varchar_pattern_ops', "address" => 'text_pattern_ops'})
+      end
+
+      it "should allow to specify actual expression only" do
+        add_index(:users, :expression => "upper(login)", :name => 'users_login_index')
+        @index = User.indexes.detect { |i| i.name == 'users_login_index' }
+        expect(@index.expression).to eq("upper((login)::text)")
+      end
+
+      it "should raise if no column given and expression is missing" do
+        expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError, /expression/)
+      end
+
+      it "should raise if expression without name is given" do
+        expect { add_index(:users, :expression => "upper(login)") }.to raise_error(ArgumentError, /name/)
+      end
+
+      it "should raise if expression is given and case_sensitive is false" do
+        expect { add_index(:users, :name => 'users_login_index', :expression => "upper(login)", :case_sensitive => false) }.to raise_error(ArgumentError, /use LOWER/i)
+      end
+
+    end
+
+    context "create table" do
+      it "defines index with expression only" do
+        define_schema do
+          create_table :users, :force => true do |t|
+            t.string :login
+            t.index :expression => "upper(login)", name: "no_column"
+          end
+        end
+        expect(User.indexes.first.expression).to eq("upper((login)::text)")
+      end
+    end
+
+    protected
+
+    def index_for(column_names)
+      @index = User.indexes.detect { |i| i.columns == Array(column_names).collect(&:to_s) }
+    end
+
+  end
+
+  protected
+  def add_index(*args)
+    migration.suppress_messages do
+      migration.add_index(*args)
+    end
+    User.reset_column_information
+  end
+
+  def remove_index(*args)
+    migration.suppress_messages do
+      migration.remove_index(*args)
+    end
+    User.reset_column_information
+  end
+
+end

data/spec/named_schema_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "with multiple schemas" do
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  before(:all) do
+    newdb = case connection.adapter_name
+            when /^mysql/i then      "CREATE SCHEMA IF NOT EXISTS schema_plus_pg_indexes_test2"
+            when /^postgresql/i then "CREATE SCHEMA schema_plus_pg_indexes_test2"
+            when /^sqlite/i then     "ATTACH ':memory:' AS schema_plus_pg_indexes_test2"
+            end
+    begin
+      ActiveRecord::Base.connection.execute newdb
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless e.message =~ /already exists/
+    end
+
+    class User < ::ActiveRecord::Base ; end
+  end
+
+  before(:each) do
+    define_schema do
+      create_table :users, :force => true do |t|
+        t.string :login
+      end
+    end
+
+    connection.execute 'DROP TABLE IF EXISTS schema_plus_pg_indexes_test2.users'
+    connection.execute 'CREATE TABLE schema_plus_pg_indexes_test2.users (id ' + case connection.adapter_name
+          when /^mysql/i then      "integer primary key auto_increment"
+          when /^postgresql/i then "serial primary key"
+          when /^sqlite/i then     "integer primary key autoincrement"
+          end + ", login varchar(255))"
+  end
+
+  context "with indexes in each schema" do
+    before(:each) do
+      connection.execute 'CREATE INDEX ' + case connection.adapter_name
+      when /^mysql/i then      "index_users_on_login ON schema_plus_pg_indexes_test2.users"
+      when /^postgresql/i then "index_users_on_login ON schema_plus_pg_indexes_test2.users"
+      when /^sqlite/i then     "schema_plus_pg_indexes_test2.index_users_on_login ON users"
+      end + " (login)"
+    end
+
+    it "should not find indexes in other schema" do
+      User.reset_column_information
+      expect(User.indexes).to be_empty
+    end
+
+    it "should find index in current schema" do
+      connection.execute 'CREATE INDEX index_users_on_login ON users (login)'
+      User.reset_column_information
+      expect(User.indexes.map(&:name)).to eq(['index_users_on_login'])
+    end
+  end
+
+end
+

data/spec/schema_dumper_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'stringio'
+
+describe "Schema dump" do
+
+  before(:all) do
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Schema.define do
+        connection.tables.each do |table| drop_table table, :cascade => true end
+
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.datetime :deleted_at
+          t.integer :first_post_id
+        end
+
+        create_table :posts, :force => true do |t|
+          t.text :body
+          t.integer :user_id
+          t.integer :first_comment_id
+          t.string :string_no_default
+          t.integer :short_id
+          t.string :str_short
+          t.integer :integer_col
+          t.float :float_col
+          t.decimal :decimal_col
+          t.datetime :datetime_col
+          t.timestamp :timestamp_col
+          t.time :time_col
+          t.date :date_col
+          t.binary :binary_col
+          t.boolean :boolean_col
+        end
+
+        create_table :comments, :force => true do |t|
+          t.text :body
+          t.integer :post_id
+          t.integer :commenter_id
+        end
+      end
+    end
+    class ::User < ActiveRecord::Base ; end
+    class ::Post < ActiveRecord::Base ; end
+    class ::Comment < ActiveRecord::Base ; end
+  end
+
+  context "index extras" do
+
+    it "should define case insensitive index" do
+      with_index Post, [:body, :string_no_default], :case_sensitive => false do
+        expect(dump_posts).to match(/"body".*index: {.*with:.*string_no_default.*case_sensitive: false/)
+      end
+    end
+
+    it "should define index with type cast" do
+      with_index Post, [:integer_col], :name => "index_with_type_cast", :expression => "LOWER(integer_col::text)" do
+        expect(dump_posts).to include(%q{t.index name: "index_with_type_cast", expression: "lower((integer_col)::text)"})
+      end
+    end
+
+
+    it "should define case insensitive index with mixed ids and strings" do
+      with_index Post, [:user_id, :str_short, :short_id, :body], :case_sensitive => false do
+        expect(dump_posts).to match(/user_id.*index: {.* with: \["str_short", "short_id", "body"\], case_sensitive: false}/)
+      end
+    end
+
+    [:integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |col_type|
+      col_name = "#{col_type}_col"
+      it "should define case insensitive index that includes an #{col_type}" do
+        with_index Post, [:user_id, :str_short, col_name, :body], :case_sensitive => false do
+          expect(dump_posts).to match(/user_id.*index: {.* with: \["str_short", "#{col_name}", "body"\], case_sensitive: false}/)
+        end
+      end
+    end
+
+    it "should define where" do
+      with_index Post, :user_id, :name => "posts_user_id_index", :where => "user_id IS NOT NULL" do
+        expect(dump_posts).to match(/user_id.*index: {.*where: "\(user_id IS NOT NULL\)"}/)
+      end
+    end
+
+    it "should define expression" do
+      with_index Post, :name => "posts_freaky_index", :expression => "USING hash (least(id, user_id))" do
+        expect(dump_posts).to include(%q{t.index name: "posts_freaky_index", using: :hash, expression: "LEAST(id, user_id)"})
+      end
+    end
+
+    it "should define operator_class" do
+      with_index Post, :body, :operator_class => 'text_pattern_ops' do
+        expect(dump_posts).to match(/body.*index:.*operator_class: "text_pattern_ops"/)
+      end
+    end
+
+    it "should define multi-column operator classes " do
+      with_index Post, [:body, :string_no_default], :operator_class => {body: 'text_pattern_ops', string_no_default: 'varchar_pattern_ops' } do
+        expect(dump_posts).to match(/body.*index:.*operator_class: {"body"=>"text_pattern_ops", "string_no_default"=>"varchar_pattern_ops"}/)
+      end
+    end
+
+    it "should dump unique: true with expression (Issue #142)" do
+      with_index Post, :name => "posts_user_body_index", :unique => true, :expression => "BTRIM(LOWER(body))" do
+        expect(dump_posts).to include(%q{t.index name: "posts_user_body_index", unique: true, expression: "btrim(lower(body))"})
+      end
+    end
+
+
+    it "should not define :case_sensitive => false with non-trivial expression" do
+      with_index Post, :name => "posts_user_body_index", :expression => "BTRIM(LOWER(body))" do
+        expect(dump_posts).to include(%q{t.index name: "posts_user_body_index", expression: "btrim(lower(body))"})
+      end
+    end
+
+    it "should define using" do
+      with_index Post, :name => "posts_body_index", :expression => "USING hash (body)" do
+        expect(dump_posts).to match(/body.*index:.*using: :hash/)
+      end
+    end
+
+    it "should not include index order for non-ordered index types" do
+      with_index Post, :user_id, :using => :hash do
+        expect(dump_posts).to match(/user_id.*index:.*using: :hash/)
+        expect(dump_posts).not_to match(%r{order})
+      end
+    end
+
+  end
+
+  protected
+
+  def with_index(*args)
+    options = args.extract_options!
+    model, columns = args
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.add_index(model.table_name, columns, options)
+    end
+    model.reset_column_information
+    begin
+      yield
+    ensure
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.remove_index(model.table_name, :name => determine_index_name(model, columns, options))
+      end
+    end
+  end
+
+  def determine_index_name(model, columns, options)
+    name = columns[:name] if columns.is_a?(Hash)
+    name ||= options[:name]
+    name ||= model.indexes.detect { |index| index.table == model.table_name.to_s && index.columns.sort == Array(columns).collect(&:to_s).sort }.name
+    name
+  end
+
+  def dump_schema(opts={})
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = Array.wrap(opts[:ignore]) || []
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  end
+
+  def dump_posts
+    dump_schema(:ignore => %w[users comments])
+  end
+
+end
+