schema_plus_pg_indexes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c7a0890c1692f1bccb36a22dd4c68c81385e2fa
+  data.tar.gz: 6aefdddf74cca2fd8f72120b2098b674a69ae97d
+SHA512:
+  metadata.gz: b4418c479638217697120b8278121e7342da4eb4595c2af12807631f9ea5c60bed98645aeb02fe83973865a707159c10d2c3dbf38702642eeb06bab5eb4968bf
+  data.tar.gz: fb4644fab3314297ad7ed94487006156630009d395cde790057a00c3818f942193a638de7dd4d53caf0cb77705d6d60367bb4a5b69f7a3aa9b73b583be6ab4ee

data/.gitignore

@@ -0,0 +1,8 @@
+/coverage
+/tmp
+/pkg
+
+*.lock
+*.log
+*.sqlite3
+!gemfiles/**/*.sqlite3

data/.travis.yml

@@ -0,0 +1,17 @@
+# This file was auto-generated by the schema_dev tool, based on the data in
+#                 ./schema_dev.yml
+# Please do not edit this file; any changes will be overwritten next time
+# schema_dev gets run.
+---
+sudo: false
+rvm:
+- 1.9.3
+- 2.1.5
+gemfile:
+- gemfiles/rails-4.2/Gemfile.postgresql
+env: POSTGRESQL_DB_USER=postgres
+addons:
+  postgresql: '9.3'
+before_script: bundle exec rake create_databases
+after_script: bundle exec rake drop_databases
+script: bundle exec rake travis

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 ronen barzel 
+
+MIT License
+
+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,76 @@
+[![Gem Version](https://badge.fury.io/rb/schema_plus_pg_indexes.svg)](http://badge.fury.io/rb/schema_plus_pg_indexes)
+[![Build Status](https://secure.travis-ci.org/SchemaPlus/schema_plus_pg_indexes.svg)](http://travis-ci.org/SchemaPlus/schema_plus_pg_indexes)
+[![Coverage Status](https://img.shields.io/coveralls/SchemaPlus/schema_plus_pg_indexes.svg)](https://coveralls.io/r/SchemaPlus/schema_plus_pg_indexes)
+[![Dependency Status](https://gemnasium.com/lomba/schema_plus_pg_indexes.svg)](https://gemnasium.com/SchemaPlus/schema_plus_pg_indexes)
+
+# schema_plus_pg_indexes
+
+Schema_plus_pg_indexes adds into `ActiveRecord` support for some additional PostgreSQL index features: expressions, operator classes, and case-insensitive indexes:
+
+    t.string :last_name,  index: { expression: 'upper(last_name)' }
+    t.string :last_name,  index: { operator_class: 'varchar_pattern_ops' }
+    t.string :last_name,  index: { with: :address, operator_class: {last_name: 'varchar_pattern_ops', address: 'text_pattern_ops' }
+    t.string :last_name,  index: { case_sensitive: false }
+
+    t.index expression: 'upper(last_name)', name: 'my_index' # no column given, must give a name
+
+Case insensitivity is a shorthand for the expression `lower(last_name)`
+
+The `ActiveRecord::ConnectionAdapters::IndexDefinition` object has the corresponding methods defined on it: `#expression`, `#operator_classes` and `#case_sensitive?`
+
+Schema_plus_pg_indexes is part of the [SchemaPlus](https://github.com/SchemaPlus/) family of Ruby on Rails extension gems.
+
+## Installation
+
+In your application's Gemfile
+
+```ruby
+gem "schema_plus_pg_indexes"
+```
+## Compatibility
+
+schema_plus_pg_indexes is tested on
+
+[//]: # SCHEMA_DEV: MATRIX - begin
+[//]: # These lines are auto-generated by schema_dev based on schema_dev.yml
+* ruby **1.9.3** with rails **4.2**, using **postgresql**
+* ruby **2.1.5** with rails **4.2**, using **postgresql**
+
+[//]: # SCHEMA_DEV: MATRIX - end
+
+
+## History
+
+### v0.1.0
+
+* Initial release
+
+## Development & Testing
+
+Are you interested in contributing to schema_plus_pg_indexes?  Thanks!  Please follow
+the standard protocol: fork, feature branch, develop, push, and issue pull request.
+
+Some things to know about to help you develop and test:
+
+* **schema_dev**:  schema_plus_pg_indexes uses [schema_dev](https://github.com/SchemaPlus/schema_dev) to
+  facilitate running rspec tests on the matrix of ruby, rails, and database
+  versions that the gem supports, both locally and on
+  [travis-ci](http://travis-ci.org/SchemaPlus/schema_plus_pg_indexes)
+
+  To to run rspec locally on the full matrix, do:
+
+        $ schema_dev bundle install
+        $ schema_dev rspec
+
+  You can also run on just one configuration at a time;  For info, see `schema_dev --help` or the
+  [schema_dev](https://github.com/SchemaPlus/schema_dev) README.
+
+  The matrix of configurations is specified in `schema_dev.yml` in
+  the project root.
+
+* **schema_monkey**: schema_plus_pg_indexes extends ActiveRecord using
+  [schema_monkey](https://github.com/SchemaPlus/schema_monkey)'s extension
+  API and protocols -- see its README for details.  If your contribution needs any additional monkey patching
+  that isn't already supported by
+  [schema_monkey](https://github.com/SchemaPlus/schema_monkey), please head
+  over there and submit a PR.

data/Rakefile

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

data/gemfiles/Gemfile.base

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec :path => File.expand_path('..', __FILE__)
+
+platform :ruby do
+    gem "byebug" if RUBY_VERSION > "2"
+end
+
+File.exist?(gemfile_local = File.expand_path('../Gemfile.local', __FILE__)) and eval File.read(gemfile_local), binding, gemfile_local

data/gemfiles/rails-4.2/Gemfile.base

@@ -0,0 +1,3 @@
+eval File.read File.expand_path('../../Gemfile.base', __FILE__)
+
+gem "rails", "~> 4.2.0"

data/gemfiles/rails-4.2/Gemfile.postgresql

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "pg"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/lib/schema_plus_pg_indexes.rb

@@ -0,0 +1,11 @@
+require 'schema_monkey'
+require 'schema_plus_indexes'
+
+require_relative 'schema_plus_pg_indexes/active_record/connection_adapters/index_definition'
+require_relative 'schema_plus_pg_indexes/middleware/migration'
+require_relative 'schema_plus_pg_indexes/middleware/postgresql/dumper'
+require_relative 'schema_plus_pg_indexes/middleware/postgresql/migration'
+require_relative 'schema_plus_pg_indexes/middleware/postgresql/query'
+require_relative 'schema_plus_pg_indexes/version'
+
+SchemaMonkey.register(SchemaPlusPgIndexes)

data/lib/schema_plus_pg_indexes/active_record/connection_adapters/index_definition.rb

@@ -0,0 +1,49 @@
+module SchemaPlusPgIndexes
+  module ActiveRecord
+    module ConnectionAdapters
+      #
+      # SchemaPlusPgIndexes extends the IndexDefinition object to return information
+      # case sensitivity, expessions, and operator classes
+      module IndexDefinition
+
+        def self.included(base)
+          base.alias_method_chain :initialize, :schema_plus_pg_indexes
+        end
+
+        attr_accessor :expression
+        attr_accessor :operator_classes
+
+        def case_sensitive?
+          @case_sensitive
+        end
+
+        def conditions
+          ActiveSupport::Deprecation.warn "ActiveRecord IndexDefinition#conditions is deprecated, used #where instead"
+          where
+        end
+
+        def kind
+          ActiveSupport::Deprecation.warn "ActiveRecord IndexDefinition#kind is deprecated, used #using instead"
+          using
+        end
+
+        def initialize_with_schema_plus_pg_indexes(*args)
+          initialize_without_schema_plus_pg_indexes(*args)
+          options = args.dup.extract_options!
+          @expression = options[:expression]
+          @operator_classes = options[:operator_classes] || {}
+          @case_sensitive = options.include?(:case_sensitive) ? options[:case_sensitive] : true
+        end
+
+        def ==(other)
+          return false if not super(other) # can use super here because == is defined in SchemaPlusIndexes which was included before us
+          return false unless self.expression == other.expression
+          return false unless !!self.case_sensitive? == !!other.case_sensitive?
+          return false unless self.operator_classes == other.operator_classes
+          return true
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_plus_pg_indexes/middleware/migration.rb

@@ -0,0 +1,23 @@
+module SchemaPlusPgIndexes
+  module Middleware
+    module Migration
+
+      def self.insert
+        SchemaMonkey::Middleware::Migration::Index.prepend DeprecateArgs
+      end
+
+      class DeprecateArgs < SchemaMonkey::Middleware::Base
+        def call(env)
+          {:conditions => :where, :kind => :using}.each do |deprecated, proper|
+            if env.options[deprecated]
+              ActiveSupport::Deprecation.warn "ActiveRecord index option #{deprecated.inspect} is deprecated, use #{proper.inspect} instead"
+              env.options[proper] = env.options.delete(deprecated)
+            end
+          end
+          continue env
+        end
+      end
+
+    end
+  end
+end

data/lib/schema_plus_pg_indexes/middleware/postgresql/dumper.rb

@@ -0,0 +1,55 @@
+module SchemaPlusPgIndexes
+  module Middleware
+    module Postgresql
+      module Dumper
+
+        def self.insert
+          SchemaMonkey::Middleware::Dumper::Indexes.append DumpExtensions
+          SchemaMonkey::Middleware::Dumper::Table.append InlineIndexes
+        end
+
+        class DumpExtensions < SchemaMonkey::Middleware::Base
+          def call(env)
+            continue env
+
+            index_defs = Dumper.get_index_defiinitions(env, env.table)
+
+            env.table.indexes.each do |index_dump|
+              index_def = index_defs.find(&its.name == index_dump.name)
+              if index_def.columns.blank?
+                index_dump.add_option "expression: #{index_def.expression.inspect}" if index_def.expression and index_def.columns.blank?
+              else
+                index_dump.add_option "case_sensitive: false" unless index_def.case_sensitive?
+                unless index_def.operator_classes.blank?
+                  if index_def.operator_classes.values.uniq.length == 1
+                    index_dump.add_option "operator_class: #{index_def.operator_classes.values.first.inspect}"
+                  else
+                    index_dump.add_option "operator_class: {" + index_def.operator_classes.map{|column, val| "#{column.inspect}=>#{val.inspect}"}.join(", ") + "}"
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        class InlineIndexes < SchemaMonkey::Middleware::Base
+          def call(env)
+            continue env
+
+            index_defs = Dumper.get_index_defiinitions(env, env.table)
+
+            env.table.indexes.select(&its.columns.blank?).each do |index|
+              env.table.statements << "t.index name: #{index.name.inspect}, #{index.options}"
+              env.table.indexes.delete(index)
+            end
+          end
+        end
+
+        def self.get_index_defiinitions(env, table_dump)
+          env.dump.data.index_definitions ||= {}
+          env.dump.data.index_definitions[table_dump.name] ||= env.connection.indexes(table_dump.name)
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus_pg_indexes/middleware/postgresql/migration.rb

@@ -0,0 +1,83 @@
+module SchemaPlusPgIndexes
+  module Middleware
+    module Postgresql
+      module Migration
+        def self.insert
+          SchemaMonkey::Middleware::Migration::IndexComponentsSql.append DefineExtensions
+        end
+
+        class DefineExtensions < SchemaMonkey::Middleware::Base
+          # SchemaPlusPgIndexes provides the following extra options for PostgreSQL
+          # indexes:
+          # * +:expression+ - SQL expression to index.  column_name can be nil or ommitted, in which case :name must be provided
+          # * +:operator_class+ - an operator class name or a hash mapping column name to operator class name
+          # * +:case_sensitive - setting to +false+ is a shorthand for :expression => 'LOWER(column_name)'
+          #
+          # The <tt>:case_sensitive => false</tt> option ties in with Rails built-in support for case-insensitive searching:
+          #    validates_uniqueness_of :name, :case_sensitive => false
+          #
+          # Since since <tt>:case_sensitive => false</tt> is implemented by
+          # using <tt>:expression</tt>, this raises an ArgumentError if both
+          # are specified simultaneously.
+          #
+          def call(env)
+            options = env.options
+            column_names = env.column_names
+            table_name = env.table_name
+            connection = env.connection
+
+            if env.column_names.empty?
+              raise ArgumentError, "No columns and :expression missing from options - cannot create index" unless options[:expression]
+              raise ArgumentError, "No columns, and index name not given. Pass :name option" unless options[:name]
+            end
+
+            expression = options.delete(:expression)
+            operator_classes = options.delete(:operator_class)
+            case_insensitive = (options.delete(:case_sensitive) == false)
+
+            if expression
+              raise ArgumentError, "Cannot specify :case_sensitive => false with an expression.  Use LOWER(column_name)" if case_insensitive
+              expression.strip!
+              if m = expression.match(/^using\s+(?<using>\S+)\s*(?<rest>.*)/i)
+                options[:using] = m[:using]
+                expression = m[:rest]
+              end
+              if m = expression.match(/^(?<rest>.*)\s+where\s+(?<where>.*)/i)
+                options[:where] = m[:where]
+                expression = m[:rest]
+              end
+            end
+
+            continue env
+
+            if operator_classes and not operator_classes.is_a? Hash
+              operator_classes = Hash[column_names.map {|name| [name, operator_classes]}]
+            end
+
+            if expression
+              env.sql.columns = expression.sub(/ ^\( (.*) \) $/x, '\1')
+            elsif operator_classes or case_insensitive
+              option_strings = Hash[column_names.map {|name| [name, '']}]
+              (operator_classes||{}).stringify_keys.each do |column, opclass|
+                option_strings[column] += " #{opclass}" if opclass
+              end
+              option_strings = connection.send :add_index_sort_order, option_strings, column_names, options
+
+              if case_insensitive
+                caseable_columns = connection.columns(table_name).select { |col| [:string, :text].include?(col.type) }.map(&:name)
+                quoted_column_names = column_names.map do |col_name|
+                  (caseable_columns.include?(col_name.to_s) ? "LOWER(#{connection.quote_column_name(col_name)})" : connection.quote_column_name(col_name)) + option_strings[col_name]
+                end
+              else
+                quoted_column_names = column_names.map { |col_name| connection.quote_column_name(col_name) + option_strings[col_name] }
+              end
+
+              env.sql.columns = quoted_column_names.join(', ')
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/schema_plus_pg_indexes/middleware/postgresql/query.rb

@@ -0,0 +1,130 @@
+module SchemaPlusPgIndexes
+  module Middleware
+    module Postgresql
+      module Query
+        def self.insert
+          SchemaMonkey::Middleware::Query::Indexes.append LookupExtensions
+        end
+
+        class LookupExtensions < SchemaMonkey::Middleware::Base
+
+          def get_opclass_names(env, opclasses)
+            @opclass_names ||= {}
+            if (missing = opclasses - @opclass_names.keys).any?
+              result = env.connection.query(<<-SQL, 'SCHEMA')
+              SELECT oid, opcname FROM pg_opclass
+              WHERE (NOT opcdefault) AND oid IN (#{opclasses.join(',')})
+              SQL
+              result.each do |oid, opcname|
+                @opclass_names[oid] = opcname
+              end
+            end
+          end
+
+          def call(env)
+            # Ideally we'd let AR do its stuff and then add the extras.
+            #
+            # But one of the extras is expressions.  AR completely strips out
+            # indexes with expressions, so to handle them we need to
+            # essentially reissue the original query and then duplicate what
+            # AR does to process them.  That being the case we may as well
+            # just skip AR's implementation and use ours.
+            #
+            # We could limit that query to just those indexes that have
+            # expressions, but we'd still have our code duplicating the AR
+            # code.  Plus, our own query can handle operator classess at the
+            # same time, but to add operator_classes to AR's definitions we'd
+            # still have to issue additional queries.  Plus, using our own
+            # query we have the opportunity to handle tables of the form
+            # 'namespace.tablename'
+            #
+            # So, we use our code and DO NOT DO:
+            #
+            #      continue env
+            #
+            result = env.connection.query(<<-SQL, 'SCHEMA')
+
+           SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
+                  m.amname, pg_get_expr(d.indpred, t.oid) as conditions, pg_get_expr(d.indexprs, t.oid) as expression,
+                  d.indclass
+           FROM pg_class t
+           INNER JOIN pg_index d ON t.oid = d.indrelid
+           INNER JOIN pg_class i ON d.indexrelid = i.oid
+           INNER JOIN pg_am m ON i.relam = m.oid
+           WHERE i.relkind = 'i'
+             AND d.indisprimary = 'f'
+             AND t.relname = '#{table_name_without_namespace(env.table_name)}'
+             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{namespace_sql(env.table_name)} )
+          ORDER BY i.relname
+            SQL
+
+            env.index_definitions += result.map do |(index_name, unique, indkey, inddef, oid, using, conditions, expression, indclass)|
+              index_keys = indkey.split(" ")
+              opclasses = indclass.split(" ")
+
+              rows = env.connection.query(<<-SQL, 'SCHEMA')
+              SELECT CAST(a.attnum as VARCHAR), a.attname, t.typname
+              FROM pg_attribute a
+              INNER JOIN pg_type t ON a.atttypid = t.oid
+              WHERE a.attrelid = #{oid}
+              SQL
+              columns = {}
+              types = {}
+              rows.each do |num, name, type|
+                columns[num] = name
+                types[name] = type
+              end
+
+              column_names = columns.values_at(*index_keys).compact
+              case_sensitive = true
+
+              # extract column names from the expression, for a
+              # case-insensitive index.
+              # only applies to character, character varying, and text
+              if expression
+                rexp_lower = %r{\blower\(\(?([^)]+)(\)::text)?\)}
+                if expression.match /\A#{rexp_lower}(?:, #{rexp_lower})*\z/
+                  case_insensitive_columns = expression.scan(rexp_lower).map(&:first).select{|column| %W[char varchar text].include? types[column]}
+                  if case_insensitive_columns.any?
+                    case_sensitive = false
+                    column_names = index_keys.map { |index_key|
+                      index_key == '0' ? case_insensitive_columns.shift : columns[index_key]
+                    }.compact
+                  end
+                end
+              end
+
+              get_opclass_names(env, opclasses)
+              operator_classes = Hash[
+                index_keys.zip(opclasses).map { |index_key, opclass| [columns[index_key], @opclass_names[opclass]] }
+              ]
+              operator_classes.delete_if{|k,v| v.nil?}
+
+              # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
+              desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
+              orders = desc_order_columns.any? ? Hash[column_names.map {|column| [column, desc_order_columns.include?(column) ? :desc : :asc]}] : {}
+
+              ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(env.table_name, column_names,
+                                                                      :name => index_name,
+                                                                      :unique => (unique == 't'),
+                                                                      :orders => orders,
+                                                                      :where => conditions,
+                                                                      :case_sensitive => case_sensitive,
+                                                                      :using => using.downcase == "btree" ? nil : using.to_sym,
+                                                                      :operator_classes => operator_classes,
+                                                                      :expression => expression)
+            end
+          end
+
+          def namespace_sql(table_name)
+            (table_name.to_s =~ /(.*)[.]/) ?  "'#{$1}'" : "ANY (current_schemas(false))"
+          end
+
+          def table_name_without_namespace(table_name)
+            table_name.to_s.sub /.*[.]/, ''
+          end
+        end
+      end
+    end
+  end
+end