pg_saurus 3.7.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac3e7bc1ed09c54ead47c936f659d1976deca96b498347b748de3411969bbd84
-  data.tar.gz: 1c0dbd26312b9cbde30f6fd7a659fa6760b3d7800f092828d9e81542fa5ceb2c
+  metadata.gz: 5b32de47fc9d97bfc956d5e2e26c9601ed2da3866dea9a51b97722c90d4b1db7
+  data.tar.gz: 497db5f622d6332efa57216e13527b71a2895125856330e320166f342e088637
 SHA512:
-  metadata.gz: 5b2fdd24acf0bbe74f4607f9d189fb90054c4f92092508a390323c0f320d8364f74638b0ff64f358a287ccc20bca78bbd63ed826018387fd7e6b6841afe7efa1
-  data.tar.gz: 3e53da8b488c17cfc6f0c168aa59c21d93dc4a1796423efe85cbc36c84b47448ff26cde61f851c24f5faed176fc39202ef383e70d5228975d326fad556728e22
+  metadata.gz: 4626a2eeaf870f6a000e048e0d7264aaf8d79486c09eaffd247358f14d83eb2cfe201f758d62b60bfb5a6da4ce5dddbdbc1ce701350920bf88c5f4396a4bb196
+  data.tar.gz: e5c098daabeaa492376e42dfbd1639439d09c9f457323e43f4f00c240d8d4a5c91b0d05ce53d41306fb9b28788bdc53115df8a3698f87e41f9d76e8dd548d804

data/README.markdown

@@ -8,7 +8,7 @@ An ActiveRecord extension to get more from PostgreSQL:
 * Create/drop [schemas](#schemas).
 * Use existing functionality in the context of [schemas](#schemas).
 * Set/remove [comments on columns and tables](#table-and-column-comments).
-* [Enhancements to the Rails 4.2 foreign key support](#foreign-keys).
+* [Enhancements to the Rails 4.2 foreign key support (PgSaurus 3.X)](#foreign-keys).
 * Use [partial indexes](#partial-indexes).
 * Use [indexes on expressions](#indexes-on-expressions).
 * Use [indexes with custom ops classes](#indexes-with-operator-classes).
@@ -33,12 +33,10 @@ PgSaurus is a fork of PgPower.
 
 ## Environment notes
 
-PgSaurus v3 was tested with Rails 4.2, Ruby 2.2.4. For Rails 4.1, use PgSaurus v2.5+.
+PgSaurus v4 was tested with Rails 5.2 and Ruby 2.4. For Rails 4.2, use PgSaurus v3. For Rails 4.1, use PgSaurus v2.5+.
+Older versions of Rails are not supported.
 
-NOTE: JRuby is not supported. The current ActiveRecord JDBC adapter has its own Rails4-compatible
-method named "create_schema" which conflicts with this gem.
-
-NOTE: PgSaurus does not support Rails 3.
+NOTE: JRuby is not supported.
 
 ## Schemas
 
@@ -179,10 +177,26 @@ If you want to remove the index, pass in the `remove_index: true` option.
 remove_foreign_key(:comments, column: :post_id, remove_index: true)
 ```
 
+### Migration notes - upgrading from Rails 4.2
+
+PgSaurus v4.X requires Rails 5. Rails 5.2 is recommended.
+You can use the new Rails 5 semantics to create comments and indexes inline.
+You also need to use the index order options using the Rails 5 semantics.
+
+```ruby
+# THIS FAILS
+add_index :books, ["author_id DESC NULLS FIRST", "publisher_id DESC NULLS LAST"],
+          name: "books_author_id_and_publisher_id"
+
+# DO THIS INSTEAD
+add_index :books, ["author_id", "publisher_id"],
+          name: "books_author_id_and_publisher_id",
+          order: { author_id: "DESC NULLS FIRST", publisher_id: "DESC NULLS LAST" }
+```
 
 ### Migration notes - upgrading from Rails 4.1
 
-PgSaurus v3+ now uses the Rails 4.2 semantics for `add_foreign_key` and `remove_foreign_key`. See http://api.rubyonrails.org/v4.2/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
+PgSaurus v3.X now uses the Rails 4.2 semantics for `add_foreign_key` and `remove_foreign_key`. See http://api.rubyonrails.org/v4.2/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
 
 A few things have changed. The most breaking change is that the syntax `remove_foreign_key :from_table, :to_table, options` no longer works.
 
@@ -460,9 +474,9 @@ PgSaurus::Tools.index_exists?(table, columns, options)   # => returns true if an
 
 ## TODO
 
-Support for Rails 5+
+Support for Rails 6+
 
-* Rails 5 introduces its own schema support. PgSaurus v4+ will have to drop any conflicting support and modify its other features to accommodate Rails 5's schema support.
+* Rails 6 support has not been tested as of yet.
 
 Possible support for JRuby:
 
@@ -490,6 +504,6 @@ Released under the MIT License.  See the MIT-LICENSE file for more details.
 
 Contributions are welcome.  However, before issuing a pull request, please make sure of the following:
 
-* All specs are passing (under ruby 1.9.3+)
+* All specs are passing (under Ruby 2.4+)
 * Any new features have test coverage.
 * Anything that breaks backward compatibility has a very good reason for doing so.

data/bin/rails

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/pg_saurus/engine', __dir__)
+APP_PATH = File.expand_path('../test/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/lib/core_ext/active_record/connection_adapters/{abstract → postgresql}/schema_statements.rb

@@ -9,6 +9,94 @@ module ActiveRecord
         # Regexp used to find the operator name (or operator string, e.g. "DESC NULLS LAST"):
         OPERATOR_REGEXP = /(.+?)\s([\w\s]+)$/
 
+        # Regex to find columns used in index statements
+        INDEX_COLUMN_EXPRESSION = /ON [\w\.]+(?: USING \w+ )?\((.+)\)/
+
+        # Regex to find where clause in index statements
+        INDEX_WHERE_EXPRESSION = /WHERE (.+)$/
+
+        # Returns an array of indexes for the given table.
+        #
+        # == Patch 1:
+        # Remove type specification from stored Postgres index definitions.
+        #
+        # == Patch 2:
+        # Split compound functional indexes to array.
+        #
+        def indexes(table_name)
+          scope = quoted_scope(table_name)
+
+          result = query(<<-SQL, "SCHEMA")
+            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
+                            pg_catalog.obj_description(i.oid, 'pg_class') AS comment
+            FROM pg_class t
+            INNER JOIN pg_index     d  ON t.oid = d.indrelid
+            INNER JOIN pg_class     i  ON d.indexrelid = i.oid
+            LEFT JOIN  pg_namespace n  ON n.oid = i.relnamespace
+            WHERE i.relkind = 'i'
+              AND d.indisprimary = 'f'
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
+            ORDER BY i.relname
+          SQL
+
+          result.map do |row|
+            index_name = row[0]
+            unique     = row[1]
+            indkey     = row[2].split(" ").map(&:to_i)
+            inddef     = row[3]
+            oid        = row[4]
+            comment    = row[5]
+
+            using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/m).flatten
+
+            orders = {}
+            opclasses = {}
+
+            if indkey.include?(0)
+              definition = inddef.sub(INDEX_WHERE_EXPRESSION, '')
+
+              if column_expression = definition.match(INDEX_COLUMN_EXPRESSION)[1]
+                columns = split_expression(expressions).map do |functional_name|
+                  remove_type(functional_name)
+                end
+
+                columns = columns.size > 1 ? columns : columns[0]
+              end
+            else
+              columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
+                SELECT a.attnum, a.attname
+                FROM pg_attribute a
+                WHERE a.attrelid = #{oid}
+                AND a.attnum IN (#{indkey.join(",")})
+              SQL
+
+              # add info on sort order (only desc order is explicitly specified, asc is the default)
+              # and non-default opclasses
+              expressions.scan(/(?<column>\w+)"?\s?(?<opclass>\w+_ops)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
+                opclasses[column] = opclass.to_sym if opclass
+                if nulls
+                  orders[column] = [desc, nulls].compact.join(" ")
+                else
+                  orders[column] = :desc if desc
+                end
+              end
+            end
+
+            IndexDefinition.new(
+              table_name,
+              index_name,
+              unique,
+              columns,
+              orders:    orders,
+              opclasses: opclasses,
+              where:     where,
+              using:     using.to_sym,
+              comment:   comment.presence
+            )
+          end
+        end
+
         # Redefine original add_index method to handle :concurrently option.
         #
         # Adds a new index to the table.  +column_name+ can be a single Symbol, or
@@ -34,10 +122,11 @@ module ActiveRecord
 
           index_name,
           index_type,
-          index_columns,
+          index_columns_and_opclasses,
           index_options,
           index_algorithm,
-          index_using      = add_index_options(table_name, column_name, options)
+          index_using,
+          comment = add_index_options(table_name, column_name, options)
 
           # GOTCHA:
           #   It ensures that there is no existing index only for the case when the index
@@ -64,7 +153,7 @@ module ActiveRecord
           statements << "ON"
           statements << quote_table_name(table_name)
           statements << index_using          if index_using.present?
-          statements << "(#{index_columns})" if index_columns.present? unless skip_column_quoting
+          statements << "(#{index_columns_and_opclasses})" if index_columns_and_opclasses.present? unless skip_column_quoting
           statements << "(#{column_name})"   if column_name.present? and skip_column_quoting
           statements << index_options        if index_options.present?
 
@@ -84,7 +173,7 @@ module ActiveRecord
         #
         def index_exists?(table_name, column_name, options = {})
           column_names = Array.wrap(column_name)
-          index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names)
+          index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, column: column_names)
 
           # Always compare the index name
           default_comparator = lambda { |index| index.name == index_name }
@@ -133,25 +222,30 @@ module ActiveRecord
               raise ArgumentError, "You must specify the index name"
             end
           else
-            index_name(table_name, :column => options)
+            index_name(table_name, column: options)
           end
         end
 
         # Override super method to provide support for expression column names.
-        def quoted_columns_for_index(column_names, options = {})
-          column_names.map do |name|
-            column_name, operator_name = split_column_name(name)
+        def quoted_columns_for_index(column_names, **options)
+          return [column_names] if column_names.is_a?(String)
 
-            result_name = if column_name =~ FUNCTIONAL_INDEX_REGEXP
-                            "#{$1}(#{$2}#{quote_column_name($3)})"
-                          else
-                            quote_column_name(column_name)
-                          end
+          quoted_columns = Hash[
+            column_names.map do |name|
+              column_name, operator_name = split_column_name(name)
 
-            result_name += " " + operator_name if operator_name
+              result_name = if column_name =~ FUNCTIONAL_INDEX_REGEXP
+                              _name = "#{$1}(#{$2}#{quote_column_name($3)})"
+                              _name += " #{operator_name}"
+                              _name
+                            else
+                              quote_column_name(column_name).dup
+                            end
+              [column_name.to_sym, result_name]
+            end
+          ]
 
-            result_name
-          end
+          add_options_for_index_columns(quoted_columns, options).values
         end
         protected :quoted_columns_for_index
 
@@ -180,6 +274,47 @@ module ActiveRecord
           end
         end
         private :split_column_name
+
+        # Splits only on commas outside of parens
+        def split_expression(expression)
+          result = []
+          parens = 0
+          buffer = ""
+
+          expression.chars do |char|
+            case char
+            when ','
+              if parens == 0
+                result.push(buffer)
+                buffer = ""
+                next
+              end
+            when '('
+              parens += 1
+            when ')'
+              parens -= 1
+            end
+
+            buffer << char
+          end
+
+          result << buffer unless buffer.empty?
+          result
+        end
+        private :split_expression
+
+        # Remove type specification from stored Postgres index definitions
+        #
+        # @param [String] column_with_type the name of the column with type
+        # @return [String]
+        #
+        # @example
+        #   remove_type("((col)::text")
+        #   => "col"
+        def remove_type(column_with_type)
+          column_with_type.sub(/\((\w+)\)::\w+/, '\1')
+        end
+        private :remove_type
       end
     end
   end

data/lib/core_ext/active_record/schema_dumper.rb

@@ -5,48 +5,26 @@ module ActiveRecord #:nodoc:
   class SchemaDumper #:nodoc:
     # Writes out index-related details to the schema stream
     #
-    # == Patch reason:
-    # {ActiveRecord::SchemaDumper#indexes} does not support writing out
-    # details related to partial indexes.
-    #
     # == Patch:
-    # Append :where clause if there's a partial index
+    # Add support of skip_column_quoting option for json indexes.
     #
-    def indexes(table, stream)
-      if (indexes = @connection.indexes(table)).any?
-        add_index_statements = indexes.map do |index|
-          columns = index.columns.map do |column_name|
-            column_name += ' ' +index.operators[column_name] if index.operators.key?(column_name)
-
-            column_name
-          end
-
-          is_json_index = (columns.count == 1 && columns.first =~ /^(.+->.+)$/)
-
-          statement_parts = [
-            ('add_index ' + index.table.inspect),
-            is_json_index ? "\"#{columns.first}\"" : columns.inspect,
-            (':name => ' + index.name.inspect),
-          ]
-          statement_parts << ':unique => true' if index.unique
-
-          index_lengths = (index.lengths || []).compact
-          statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
-
-          # Patch
-          #  Append :where clause if a partial index
-          statement_parts << (':where => ' + index.where.inspect) if index.where
-
-          statement_parts << (':using => ' + index.access_method.inspect) unless index.access_method.downcase == 'btree'
-
-          statement_parts << ':skip_column_quoting => true' if is_json_index
-
-          '  ' + statement_parts.join(', ')
-        end
-
-        stream.puts add_index_statements.sort.join("\n")
-        stream.puts
-      end
+    def index_parts(index)
+      is_json_index = index.columns.is_a?(String) && index.columns =~ /^(.+->.+)$/
+
+      index_parts = [
+        index.columns.inspect,
+        "name: #{index.name.inspect}",
+      ]
+      index_parts << "unique: true" if index.unique
+      index_parts << "length: #{format_index_parts(index.lengths)}" if index.lengths.present?
+      index_parts << "order: #{format_index_parts(index.orders)}" if index.orders.present?
+      index_parts << "opclass: #{format_index_parts(index.opclasses)}" if index.opclasses.present?
+      index_parts << "where: #{index.where.inspect}" if index.where
+      index_parts << "using: #{index.using.inspect}" if !@connection.default_index_type?(index)
+      index_parts << "skip_column_quoting: true" if is_json_index
+      index_parts << "type: #{index.type.inspect}" if index.type
+      index_parts << "comment: #{index.comment.inspect}" if index.comment
+      index_parts
     end
   end
 end

data/lib/pg_saurus/connection_adapters.rb

@@ -4,7 +4,6 @@ module PgSaurus::ConnectionAdapters # :nodoc:
   autoload :AbstractAdapter
   autoload :PostgreSQLAdapter,  'pg_saurus/connection_adapters/postgresql_adapter'
   autoload :Table
-  autoload :IndexDefinition,    'pg_saurus/connection_adapters/index_definition'
   autoload :FunctionDefinition, 'pg_saurus/connection_adapters/function_definition'
   autoload :TriggerDefinition,  'pg_saurus/connection_adapters/trigger_definition'
 end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/extension_methods.rb

@@ -3,16 +3,16 @@
 module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
   # Default options for {#create_extension} method.
   CREATE_EXTENSION_DEFAULTS = {
-      :if_not_exists => true,
-      :schema_name   => nil,
-      :version       => nil,
-      :old_version   => nil
+      if_not_exists: true,
+      schema_name:   nil,
+      version:       nil,
+      old_version:   nil
   }
 
   # Default options for {#drop_extension} method.
   DROP_EXTENSION_DEFAULTS = {
-      :if_exists => true,
-      :mode      => :restrict
+      if_exists: true,
+      mode:      :restrict
   }
 
   # The modes which determine postgresql behavior on DROP EXTENSION operation.
@@ -20,8 +20,8 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
   # *:restrict* refuse to drop the extension if any objects depend on it
   # *:cascade* automatically drop objects that depend on the extension
   AVAILABLE_DROP_MODES = {
-      :restrict => 'RESTRICT',
-      :cascade  => 'CASCADE'
+      restrict: 'RESTRICT',
+      cascade:  'CASCADE'
   }
 
   # @return [Boolean] if adapter supports postgresql extension manipulation
@@ -127,8 +127,8 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
       [
           row['ext_name'],
           {
-              :schema_name => row['schema_name'],
-              :version => row['ext_version']
+              schema_name: row['schema_name'],
+              version:     row['ext_version']
           }
       ]
     end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/foreign_key_methods.rb

@@ -2,7 +2,6 @@ module PgSaurus # :nodoc:
   # Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
   # to support foreign keys feature.
   module ConnectionAdapters::PostgreSQLAdapter::ForeignKeyMethods
-
     # Drop table and optionally disable triggers.
     # Changes adapted from https://github.com/matthuhiggins/foreigner/blob/e72ab9c454c156056d3f037d55e3359cd972af32/lib/foreigner/connection_adapters/sql2003.rb
     # NOTE: Disabling referential integrity requires superuser access in postgres.
@@ -22,7 +21,8 @@ module PgSaurus # :nodoc:
     end
 
     # See activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
-    # Creates index on the FK column by default. Pass in the option :exclude_index => true
+    #
+    # Creates index on the FK column by default. Pass in the option exclude_index: true
     # to disable this.
     def add_foreign_key(from_table, to_table, options = {})
       exclude_index = (options.has_key?(:exclude_index) ? options.delete(:exclude_index) : false)
@@ -42,23 +42,30 @@ module PgSaurus # :nodoc:
     end
 
     # See activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+    #
+    # Pass in the option remove_index: true to remove index as well.
     def remove_foreign_key(from_table, options_or_to_table = {})
       if options_or_to_table.is_a?(Hash) && options_or_to_table[:remove_index]
         column = options_or_to_table[:column]
         remove_index from_table, column
+        options_or_to_table.delete(:remove_index)
       end
 
       super(from_table, options_or_to_table)
     end
 
     # See: activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+    #
+    # Removes schema name from table name.
     def foreign_key_column_for(table_name)
       table = table_name.to_s.split('.').last
 
       super table
     end
 
-    # see activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+    # See activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+    #
+    # Add from_schema option to foreign key definition options.
     def foreign_keys(table_name)
       namespace  = table_name.to_s.split('.').first
       table_name = table_name.to_s.split('.').last
@@ -99,7 +106,5 @@ module PgSaurus # :nodoc:
         ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
       end
     end
-
-
   end
 end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/index_methods.rb

@@ -18,25 +18,4 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::IndexMethods
   def index_name(table_name, options) #:nodoc:
     super.gsub('.','_')
   end
-
-  # Overrides ActiveRecord::ConnectionAdapters::SchemaStatements.index_name_for_remove
-  # to support schema notation. Prepends the schema name to the index name.
-  #
-  # === Example
-  #  drop_index 'demography.citizens', :country_id
-  #  # produces
-  #  DROP INDEX "demography"."index_demography_citizens_on_country_id"
-  #  # instead of
-  #  DROP INDEX "index_demography_citizens_on_country_id"
-  #
-  def index_name_for_remove(table_name, options = {})
-    index_name = super
-
-    if table_name.include?('.') # schema notation
-      schema = table_name.split('.').first
-      "#{schema}.#{index_name}"
-    else
-      index_name
-    end
-  end
 end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/schema_methods.rb

@@ -1,18 +1,6 @@
 # Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
 # to support schemas feature.
 module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
-  # Creates new schema in DB.
-  # @param [String] schema_name
-  def create_schema(schema_name)
-    ::PgSaurus::Tools.create_schema(schema_name)
-  end
-
-  # Drops schema in DB.
-  # @param [String] schema_name
-  def drop_schema(schema_name)
-    ::PgSaurus::Tools.drop_schema(schema_name)
-  end
-
   # Move table to another schema
   # @param [String] table table name. Can be with schema prefix e.g. "demography.people"
   # @param [String] schema schema where table should be moved to.

data/lib/pg_saurus/connection_adapters/postgresql_adapter/translate_exception.rb

@@ -12,7 +12,7 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::TranslateException
     when INSUFFICIENT_PRIVILEGE
       exc_message = exception_result.try(:error_field, PG::Result::PG_DIAG_MESSAGE_PRIMARY)
       exc_message ||= message
-      ::ActiveRecord::InsufficientPrivilege.new(exc_message, exception)
+      ::ActiveRecord::InsufficientPrivilege.new(exc_message)
     else
       super
     end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/trigger_methods.rb

@@ -15,11 +15,7 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::TriggerMethods
     for_each   = options[:for_each] || 'ROW'
     constraint = options[:constraint]
 
-    sql = if constraint
-            "CREATE CONSTRAINT TRIGGER #{trigger_name(proc_name, options)}\n  #{event}\n"
-          else
-            "CREATE TRIGGER #{trigger_name(proc_name, options)}\n  #{event}\n"
-          end
+    sql = "CREATE #{!!constraint ? "CONSTRAINT " : ""}TRIGGER #{trigger_name(proc_name, options)}\n  #{event}\n"
 
     sql << "  ON #{quote_table_or_view(table_name, options)}\n"
     if constraint

data/lib/pg_saurus/create_index_concurrently.rb

@@ -133,7 +133,7 @@ module PgSaurus::CreateIndexConcurrently
   module MigrationProxy
     # :nodoc:
     def self.included(klass)
-      klass.delegate :process_postponed_queries, :to => :migration
+      klass.delegate :process_postponed_queries, to: :migration
     end
   end
 

data/lib/pg_saurus/engine.rb

@@ -2,14 +2,11 @@ module PgSaurus
   # :nodoc:
   class Engine < Rails::Engine
 
-    initializer 'pg_saurus' do
+    initializer "pg_saurus" do
       ActiveSupport.on_load(:active_record) do
         # load monkey patches
-        ['schema_dumper',
-         'errors',
-         'connection_adapters/postgresql_adapter',
-         'connection_adapters/abstract/schema_statements'].each do |path|
-          require ::PgSaurus::Engine.root + 'lib/core_ext/active_record/' + path
+        %w(schema_dumper errors connection_adapters/postgresql/schema_statements).each do |path|
+          require ::PgSaurus::Engine.root + "lib/core_ext/active_record/" + path
         end
 
         ActiveRecord::SchemaDumper.class_eval do
@@ -35,14 +32,16 @@ module PgSaurus
           end
         end
 
-        # Follow three include statements add support for concurrently
-        #   index creation in migrations.
+        # The following three include statements add support for concurrently
+        #   creating indexes in migrations.
         ActiveRecord::Migration.class_eval do
           include ::PgSaurus::CreateIndexConcurrently::Migration
         end
+
         ActiveRecord::Migrator.class_eval do
           prepend PgSaurus::CreateIndexConcurrently::Migrator
         end
+
         ActiveRecord::MigrationProxy.class_eval do
           include ::PgSaurus::CreateIndexConcurrently::MigrationProxy
         end
@@ -56,13 +55,7 @@ module PgSaurus
           include ::PgSaurus::ConnectionAdapters::AbstractAdapter
         end
 
-        if defined?(ActiveRecord::ConnectionAdapters::JdbcAdapter)
-          sql_adapter_class = ActiveRecord::ConnectionAdapters::JdbcAdapter
-        else
-          sql_adapter_class = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-        end
-
-        sql_adapter_class.class_eval do
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
           prepend ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
           prepend ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ForeignKeyMethods
 

data/lib/pg_saurus/migration/command_recorder/schema_methods.rb

@@ -1,29 +1,17 @@
 # Provides methods to extend ActiveRecord::Migration::CommandRecorder to
 # support multi schemas feature.
 module  PgSaurus::Migration::CommandRecorder::SchemaMethods
-  # :nodoc:
-  def create_schema(*args)
-    record(:create_schema, args)
-  end
-
-  # :nodoc:
-  def drop_schema(*args)
-    record(:drop_schema, args)
-  end
-
-  # :nodoc:
-  def move_table_to_schema(*args)
-    record(:move_table_to_schema, args)
-  end
-
-  # :nodoc:
-  def create_schema_if_not_exists(*args)
-    record(:create_schema_if_not_exists, args)
-  end
 
-  # :nodoc:
-  def drop_schema_if_exists(*args)
-    record(:drop_schema_if_exists, args)
+  [
+    :create_schema,
+    :drop_schema,
+    :move_table_to_schema,
+    :create_schema_if_not_exists,
+    :drop_schema_if_exists
+  ].each do |method_name|
+    define_method(method_name) do |*args|
+      record method_name, args
+    end
   end
 
   # :nodoc:

data/lib/pg_saurus/schema_dumper/foreign_key_methods.rb

@@ -37,7 +37,7 @@ module PgSaurus::SchemaDumper::ForeignKeyMethods
         #  If an index was created in a migration, it will get dumped to the schema
         #  separately from the foreign key.  This will raise an exception if
         #  add_foreign_key is run without :exclude_index => true.
-        parts << ":exclude_index => true"
+        parts << "exclude_index: true"
 
         "  #{parts.join(', ')}"
       end

data/lib/pg_saurus/tools.rb

@@ -12,38 +12,22 @@ module PgSaurus
   module Tools
     extend self
 
-    # Creates PostgreSQL schema
-    def create_schema(schema_name)
-      sql = %{CREATE SCHEMA "#{schema_name}"}
-      connection.execute sql
-    end
-
     # Create a schema if it does not exist yet.
     #
     # @note
-    #   CREATE SCHEMA IF EXISTS appeared only in PostgreSQL 9.3
-    #   It is not used here for backward compatibility.
+    #   Supports PostgreSQL 9.3+
     #
     # @return [void]
     def create_schema_if_not_exists(schema_name)
-      unless schemas.include?(schema_name.to_s)
-        create_schema(schema_name)
-      end
+      sql = %{CREATE SCHEMA IF NOT EXISTS "#{schema_name}"}
+      connection.execute sql
     end
 
     # Ensure schema does not exists.
     #
     # @return [void]
     def drop_schema_if_exists(schema_name)
-      if schemas.include?(schema_name.to_s)
-        drop_schema(schema_name)
-      end
-    end
-
-    # Drops PostgreSQL schema
-    def drop_schema(schema_name)
-      sql = %{DROP SCHEMA "#{schema_name}"}
-      connection.execute sql
+      connection.drop_schema(schema_name, if_exists: true)
     end
 
     # Returns an array of existing schemas.

data/lib/pg_saurus/version.rb

@@ -1,4 +1,4 @@
 module PgSaurus
   # Version of pg_saurus gem.
-  VERSION = "3.7.1"
+  VERSION = "4.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_saurus
 version: !ruby/object:Gem::Version
-  version: 3.7.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Potapov Sergey
@@ -13,78 +13,78 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-18 00:00:00.000000000 Z
+date: 2019-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 5.2.3
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -183,6 +183,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ActiveRecord extensions for PostgreSQL. Provides useful tools for schema,
   foreign_key, index, function, trigger, comment and extension manipulations in migrations.
 email:
@@ -191,15 +205,16 @@ email:
 - cryo28@gmail.com
 - matt.dressel@gmail.com
 - rubygems.org@bruceburdick.com
-executables: []
+executables:
+- rails
 extensions: []
 extra_rdoc_files:
 - README.markdown
 files:
 - README.markdown
+- bin/rails
 - lib/colorized_text.rb
-- lib/core_ext/active_record/connection_adapters/abstract/schema_statements.rb
-- lib/core_ext/active_record/connection_adapters/postgresql_adapter.rb
+- lib/core_ext/active_record/connection_adapters/postgresql/schema_statements.rb
 - lib/core_ext/active_record/errors.rb
 - lib/core_ext/active_record/schema_dumper.rb
 - lib/generators/pg_saurus/install/install_generator.rb
@@ -215,7 +230,6 @@ files:
 - lib/pg_saurus/connection_adapters/abstract_adapter/trigger_methods.rb
 - lib/pg_saurus/connection_adapters/foreign_key_definition.rb
 - lib/pg_saurus/connection_adapters/function_definition.rb
-- lib/pg_saurus/connection_adapters/index_definition.rb
 - lib/pg_saurus/connection_adapters/postgresql_adapter.rb
 - lib/pg_saurus/connection_adapters/postgresql_adapter/comment_methods.rb
 - lib/pg_saurus/connection_adapters/postgresql_adapter/extension_methods.rb

data/lib/core_ext/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,261 +0,0 @@
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    # Patched version:  3.1.3
-    # Patched methods::
-    #   * indexes
-    class PostgreSQLAdapter
-      # Regex to find columns used in index statements
-      INDEX_COLUMN_EXPRESSION = /ON [\w\.]+(?: USING \w+ )?\((.+)\)/
-      # Regex to find where clause in index statements
-      INDEX_WHERE_EXPRESSION = /WHERE (.+)$/
-
-      # Taken from https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_index.h#L75
-      # Values are in reverse order
-      INDOPTION_DESC        = 1
-      # NULLs are first instead of last
-      INDOPTION_NULLS_FIRST = 2
-
-      # Returns the list of all tables in the schema search path or a specified schema.
-      #
-      # == Patch:
-      # If current user is not `postgres` original method return all tables from all schemas
-      # without schema prefix. This disables such behavior by querying only default schema.
-      # Tables with schemas will be queried later.
-      #
-      def tables(name = nil)
-        query(<<-SQL, 'SCHEMA').map { |row| row[0] }
-            SELECT tablename
-            FROM pg_tables
-            WHERE schemaname = ANY (ARRAY['public'])
-        SQL
-      end
-
-      # Checks if index exists for given table.
-      #
-      # == Patch:
-      # Search using provided schema if table_name includes schema name.
-      #
-      def index_name_exists?(table_name, index_name, default)
-        postgre_sql_name = PostgreSQL::Utils.extract_schema_qualified_name(table_name)
-        schema, table = postgre_sql_name.schema, postgre_sql_name.identifier
-        schemas = schema ? "ARRAY['#{schema}']" : 'current_schemas(false)'
-
-        exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
-          SELECT COUNT(*)
-          FROM pg_class t
-          INNER JOIN pg_index d ON t.oid = d.indrelid
-          INNER JOIN pg_class i ON d.indexrelid = i.oid
-          WHERE i.relkind = 'i'
-            AND i.relname = '#{index_name}'
-            AND t.relname = '#{table}'
-            AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (#{schemas}) )
-        SQL
-      end
-
-      # Returns an array of indexes for the given table.
-      #
-      # == Patch 1 reason:
-      # Since {ActiveRecord::SchemaDumper#tables} is patched to process tables
-      # with a schema prefix, the {#indexes} method receives table_name as
-      # "<schema>.<table>". This patch allows it to handle table names with
-      # a schema prefix.
-      #
-      # == Patch 1:
-      # Search using provided schema if table_name includes schema name.
-      #
-      # == Patch 2 reason:
-      # {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#indexes} is patched
-      # to support partial indexes using :where clause.
-      #
-      # == Patch 2:
-      # Search the postgres indexdef for the where clause and pass the output to
-      # the custom {PgSaurus::ConnectionAdapters::IndexDefinition}
-      #
-      def indexes(table_name, name = nil)
-        postgre_sql_name = PostgreSQL::Utils.extract_schema_qualified_name(table_name)
-        schema, table = postgre_sql_name.schema, postgre_sql_name.identifier
-        schemas = schema ? "ARRAY['#{schema}']" : 'current_schemas(false)'
-
-        result = query(<<-SQL, name)
-          SELECT distinct i.relname,
-                          d.indisunique,
-                          d.indkey,
-                          pg_get_indexdef(d.indexrelid),
-                          t.oid,
-                          am.amname,
-                          d.indclass,
-                          d.indoption
-          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    am ON i.relam = am.oid
-          WHERE i.relkind = 'i'
-            AND d.indisprimary = 'f'
-            AND t.relname = '#{table}'
-            AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (#{schemas}) )
-         ORDER BY i.relname
-        SQL
-
-        result.map do |row|
-          index = {
-            :name          => row[0],
-            :unique        => row[1] == 't',
-            :keys          => row[2].split(" "),
-            :definition    => row[3],
-            :id            => row[4],
-            :access_method => row[5], 
-            :operators     => row[6].split(" "),
-            :options       => row[7].split(" ").map(&:to_i)
-          }
-
-          column_names = find_column_names(table_name, index)
-
-          operator_names = find_operator_names(column_names, index)
-
-          unless column_names.empty?
-            where   = find_where_statement(index)
-            lengths = find_lengths(index)
-
-            PgSaurus::ConnectionAdapters::IndexDefinition.new(
-              table_name,
-              index[:name],
-              index[:unique],
-              column_names,
-              lengths,
-              where,
-              index[:access_method],
-              operator_names
-            )
-          end
-        end.compact
-      end
-
-      # Find column names from index attributes. If the columns are virtual (i.e.
-      # this is an expression index) then it will try to return the functions
-      # that represent each column.
-      #
-      # @param [String] table_name the name of the table, possibly schema-qualified
-      # @param [Hash] index index attributes
-      # @return [Array]
-      def find_column_names(table_name, index)
-        columns = Hash[query(<<-SQL, "Columns for index #{index[:name]} on #{table_name}")]
-          SELECT a.attnum, a.attname
-          FROM pg_attribute a
-          WHERE a.attrelid = #{index[:id]}
-          AND a.attnum IN (#{index[:keys].join(",")})
-        SQL
-
-        column_names = columns.values_at(*index[:keys]).compact
-
-        if column_names.empty?
-          definition = index[:definition].sub(INDEX_WHERE_EXPRESSION, '')
-          if column_expression = definition.match(INDEX_COLUMN_EXPRESSION)[1]
-            column_names = split_expression(column_expression).map do |functional_name|
-              remove_type(functional_name)
-            end
-          end
-        else
-          # In case if column_names if not empty it contains list of column name taken from pg_attribute table.
-          # So we need to check indoption column and add DESC and NULLS LAST based on its value.
-          # https://stackoverflow.com/questions/18121103/how-to-get-the-index-column-orderasc-desc-nulls-first-from-postgresql/18128457#18128457
-          column_names = column_names.map.with_index do |column_name, column_index|
-            option = index[:options][column_index]
-
-            if option != 0
-              column_name << " DESC" if option & INDOPTION_DESC > 0
-
-              if option & INDOPTION_NULLS_FIRST > 0
-                column_name << " NULLS FIRST"
-              else
-                column_name << " NULLS LAST"
-              end
-            end
-
-            column_name
-          end
-        end
-
-        column_names
-      end
-
-      # Find non-default operator class names for columns from index.
-      #
-      # @param column_names [Array] List of columns from index.
-      # @param index [Hash] index index attributes
-      # @return [Hash]
-      def find_operator_names(column_names, index)
-        column_names.each_with_index.inject({}) do |class_names, (column_name, column_index)|
-          result = query(<<-SQL, "Classes for columns for index #{index[:name]} for column #{column_name}")
-            SELECT op.opcname, op.opcdefault
-            FROM pg_opclass op
-            WHERE op.oid = #{index[:operators][column_index]};
-          SQL
-
-          row = result.first
-
-          if row && row[1] == "f"
-            class_names[column_name] = row[0]
-          end
-
-          class_names
-        end
-      end
-
-      # Splits only on commas outside of parens
-      def split_expression(expression)
-        result = []
-        parens = 0
-        buffer = ""
-
-        expression.chars do |char|
-          case char
-          when ','
-            if parens == 0
-              result.push(buffer)
-              buffer = ""
-              next
-            end
-          when '('
-            parens += 1
-          when ')'
-            parens -= 1
-          end
-
-          buffer << char
-        end
-
-        result << buffer unless buffer.empty?
-        result
-      end
-
-      # Find where statement from index definition
-      #
-      # @param [Hash] index index attributes
-      # @return [String] where statement
-      def find_where_statement(index)
-        index[:definition].scan(INDEX_WHERE_EXPRESSION).flatten[0]
-      end
-
-      # Find length of index
-      # TODO Update lengths once we merge in ActiveRecord code that supports it. -dresselm 20120305
-      #
-      # @param [Hash] index index attributes
-      # @return [Array]
-      def find_lengths(index)
-        []
-      end
-
-      # Remove type specification from stored Postgres index definitions
-      #
-      # @param [String] column_with_type the name of the column with type
-      # @return [String]
-      #
-      # @example
-      #   remove_type("((col)::text")
-      #   => "col"
-      def remove_type(column_with_type)
-        column_with_type.sub(/\((\w+)\)::\w+/, '\1')
-      end
-    end
-  end
-end

data/lib/pg_saurus/connection_adapters/index_definition.rb

@@ -1,8 +0,0 @@
-module PgSaurus::ConnectionAdapters
-  # Structure to store index parameters
-  # Overrides ActiveRecord::ConnectionAdapters::IndexDefinition
-  # with the additional :where parameter.
-  class IndexDefinition < Struct.new( :table, :name, :unique, :columns,
-                                      :lengths, :where, :access_method, :operators )
-  end
-end