pg_power 1.1.0 → 1.3.0

data/README.markdown

@@ -169,7 +169,15 @@ expressions are supported.
 Add an index to a column with a function
 
 ```ruby
-    add_index(:comments, "lower(text)")
+  add_index(:comments, "lower(text)")
+```
+
+You can also specify index access method
+
+```ruby
+  create_extension 'btree_gist'
+  create_extension 'fuzzystrmatch'
+  add_index(:comments, 'dmetaphone(author)', :using => 'gist')
 ```
 
 ## Concurrent index creation
@@ -191,6 +199,39 @@ Add an index concurrently along with foreign key
     add_foreign_key :table1, :table2, :column => :column_id, :concurrent_index => true
 ```
 
+## Loading/Unloading postgresql extension modules
+
+Postgresql is shipped with a number of [extension modules](http://www.postgresql.org/docs/9.1/static/contrib.html).
+PgPower provides some tools
+to [load](http://www.postgresql.org/docs/9.1/static/sql-createextension.html)/[unload](http://www.postgresql.org/docs/9.1/static/sql-dropextension.html)
+such modules by the means of migrations.
+
+Please note. CREATE/DROP EXTENSION command has been introduced in postgresql 9.1 only. So this functionality will not be
+available for the previous versions.
+
+### Examples
+
+Load [fuzzystrmatch](http://www.postgresql.org/docs/9.1/static/fuzzystrmatch.html) extension module
+and create its objects in schema *public*:
+
+```ruby
+   create_extension "fuzzystrmatch"
+```
+
+
+Load version *1.0* of the [btree_gist](http://www.postgresql.org/docs/9.1/static/btree-gist.html) extension module
+and create its objects in schema *demography*.
+
+```ruby
+   create_extension "btree_gist", :schema_name => "demography", :version => "1.0"
+```
+
+Unload extension module:
+
+```ruby
+  drop_extension "fuzzystrmatch"
+```
+
 ## Tools
 
 PgPower::Tools provides number of useful methods:
@@ -203,18 +244,13 @@ PgPower::Tools.index_exists?(table, columns, options)   # => returns true if an
 ```
 ## Running tests:
 
+* Ensure your postgresql has postgres-contrib (Ubuntu) package installed. Tests depend on btree_gist and fuzzystrmatch extensions
 * Configure `spec/dummy/config/database.yml` for development and test environments.
 * Run `rake spec`.
 * Make sure migrations don't raise exceptions and all specs pass.
 
 ## TODO:
 
-Add next syntax to create table:
-```ruby
-create_table "table_name", :schema => "schema_name" do |t|
-  # columns goes here
-end
-```
 Support for JRuby:
 
 * Jdbc driver provides its own `create_schema(schema, user)` method - solve conflicts.
@@ -224,6 +260,7 @@ Support for JRuby:
 * [Potapov Sergey](https://github.com/greyblake) - schema support
 * [Arthur Shagall](https://github.com/albertosaurus) - thanks for [pg_comment](https://github.com/albertosaurus/pg_comment)
 * [Matthew Higgins](https://github.com/matthuhiggins) - thanks for [foreigner](https://github.com/matthuhiggins/foreigner), which was used as a base for the foreign key support
+* [Artem Ignatyev](https://github.com/cryo28) - extension modules load/unload support
 * [Marcelo Silveira](https://github.com/mhfs) - thanks for rails partial index support that was backported into this gem
 
 ## Copyright and License

data/lib/core_ext/active_record/connection_adapters/abstract/schema_statements.rb

@@ -9,7 +9,7 @@ module ActiveRecord
       # an Array of Symbols.
       #
       # ====== Creating a partial index
-      #  add_index(:accounts, [:branch_id, :party_id],
+      #  add_index(:accounts, [:branch_id, :party_id], :using => 'BTree'
       #   :unique => true, :concurrently => true, :where => 'active')
       # generates
       #  CREATE UNIQUE INDEX CONCURRENTLY
@@ -38,8 +38,14 @@ module ActiveRecord
             "column can not be created concurrently, because such index already exists."
         end
 
-        execute "CREATE #{type} INDEX #{creation_method} #{quote_column_name(name)} " \
-          "ON #{quote_table_name(table_name)} (#{columns})#{opts}"
+        sql = ["CREATE #{type} INDEX"]
+        sql << creation_method.to_s
+        sql << quote_column_name(name)
+        sql << "ON #{quote_table_name(table_name)}"
+        sql << "USING #{options[:using].to_s.downcase}" if options[:using]
+        sql << "(#{columns})#{opts}"
+
+        execute sql.join(" ")
       end
 
       # Checks to see if an index exists on a table for a given index definition.

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

@@ -42,10 +42,11 @@ module ActiveRecord # :nodoc:
         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
+          SELECT distinct i.relname, d.indisunique, d.indkey,  pg_get_indexdef(d.indexrelid), t.oid, am.amname
           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}'
@@ -55,11 +56,12 @@ module ActiveRecord # :nodoc:
 
         result.map do |row|
           index = {
-            :name       => row[0],
-            :unique     => row[1] == 't',
-            :keys       => row[2].split(" "),
-            :definition => row[3],
-            :id         => row[4]
+            :name          => row[0],
+            :unique        => row[1] == 't',
+            :keys          => row[2].split(" "),
+            :definition    => row[3],
+            :id            => row[4],
+            :access_method => row[5]
           }
 
           column_names = find_column_names(table_name, index)
@@ -68,7 +70,7 @@ module ActiveRecord # :nodoc:
             where   = find_where_statement(index)
             lengths = find_lengths(index)
 
-            PgPower::ConnectionAdapters::IndexDefinition.new(table_name, index[:name], index[:unique], column_names, lengths, where)
+            PgPower::ConnectionAdapters::IndexDefinition.new(table_name, index[:name], index[:unique], column_names, lengths, where, index[:access_method])
           end
         end.compact
       end

data/lib/core_ext/active_record/schema_dumper.rb

@@ -29,6 +29,8 @@ module ActiveRecord #:nodoc:
           #  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.join(', ')
         end
 

data/lib/pg_power/connection_adapters/index_definition.rb

@@ -1,6 +1,6 @@
 module PgPower::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)
+  class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :where, :access_method)
   end
 end

data/lib/pg_power/connection_adapters/postgresql_adapter.rb

@@ -5,12 +5,14 @@ module PgPower::ConnectionAdapters::PostgreSQLAdapter
   extend ActiveSupport::Concern
 
   # TODO: Looks like explicit path specification can be omitted -- aignatyev 20120904
+  autoload :ExtensionMethods,      'pg_power/connection_adapters/postgresql_adapter/extension_methods'
   autoload :SchemaMethods,      'pg_power/connection_adapters/postgresql_adapter/schema_methods'
   autoload :CommentMethods,     'pg_power/connection_adapters/postgresql_adapter/comment_methods'
   autoload :ForeignerMethods,   'pg_power/connection_adapters/postgresql_adapter/foreigner_methods'
   autoload :IndexMethods,       'pg_power/connection_adapters/postgresql_adapter/index_methods'
   autoload :TranslateException, 'pg_power/connection_adapters/postgresql_adapter/translate_exception'
 
+  include ExtensionMethods
   include SchemaMethods
   include CommentMethods
   include ForeignerMethods

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

@@ -0,0 +1,118 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support extensions feature.
+module PgPower::ConnectionAdapters::PostgreSQLAdapter::ExtensionMethods
+  # Default options for {#create_extension} method
+  CREATE_EXTENSION_DEFAULTS = {
+      :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
+  }
+
+  # The modes which determine postgresql behavior on DROP EXTENSION operation.
+  #
+  # *: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'
+  }
+
+  # @return [Boolean] if adapter supports postgresql extension manipulation
+  def supports_extensions?
+    true
+  end
+
+  # Executes SQL to load a postgresql extension module into the current database
+  #
+  # @param [#to_s] extension_name Name of the extension module to load
+  # @param [Hash] options
+  # @option options [Boolean] :if_not_exists should the 'IF NOT EXISTS' clause be added
+  # @option options [#to_s,nil] :schema_name The name of the schema in which to install the extension's objects
+  # @option options [#to_s,nil] :version The version of the extension to install
+  # @option options [#to_s,nil] :old_version Alternative installation script name
+  #    that absorbs the existing objects into the extension, instead of creating new objects
+  def create_extension(extension_name, options = {})
+    options = CREATE_EXTENSION_DEFAULTS.merge(options.symbolize_keys)
+    sql = ['CREATE EXTENSION']
+    sql << 'IF NOT EXISTS' if options[:if_not_exists]
+    sql << extension_name.to_s
+    sql << "SCHEMA #{options[:schema_name]}" if options[:schema_name].present?
+    sql << "VERSION '#{options[:version]}'"    if options[:version].present?
+    sql << "FROM #{options[:old_version]}"   if options[:old_version].present?
+
+    sql = sql.join(' ')
+    execute(sql)
+  end
+
+
+  # Executes SQL to remove a postgresql extension module from the current database
+  #
+  # @param [#to_s] extension_name Name of the extension module to unload
+  # @param [Hash] options
+  # @option options [Boolean] :if_exists should the 'IF EXISTS' clause be added
+  # @option options [Symbol] :mode Operation mode. See {AVAILABLE_DROP_MODES} for details
+  def drop_extension(extension_name, options = {})
+    options = DROP_EXTENSION_DEFAULTS.merge(options.symbolize_keys)
+
+    sql = ['DROP EXTENSION']
+    sql << 'IF EXISTS' if options[:if_exists]
+    sql << extension_name.to_s
+
+    mode = options[:mode]
+    if mode.present?
+      mode = mode.to_sym
+
+      unless AVAILABLE_DROP_MODES.include?(mode)
+        raise ArgumentError, "Expected one of #{AVAILABLE_DROP_MODES.KEYS.inspect} drop modes, but #{mode} received"
+      end
+
+      sql << AVAILABLE_DROP_MODES[mode]
+    end
+
+    sql = sql.join(' ')
+    execute(sql)
+  end
+
+  # Queries pg_catalog for all loaded to the current database extension modules
+  #
+  # Please note all extensions which belong to pg_catalog schema are omitted
+  # ===Example
+  #
+  #   extension # => {
+  #     "fuzzystrmatch" => {:schema_name => "public", :version => "1.0" }
+  #   }
+  #
+  # @return [Hash{String => Hash{Symbol => String}}] A list of loaded extensions with their options
+  def extensions
+    # Check postgresql version to not break on Postgresql < 9.1 during schema dump
+    pg_version_str = select_value('SELECT version()')
+    return {} unless pg_version_str =~ /^PostgreSQL (\d+\.\d+.\d+)/ && ($1 >= '9.1')
+
+    sql = <<-SQL
+      SELECT pge.extname AS ext_name, pgn.nspname AS schema_name, pge.extversion AS ext_version
+      FROM pg_extension pge
+      INNER JOIN pg_namespace pgn on pge.extnamespace = pgn.oid
+      WHERE pgn.nspname <> 'pg_catalog'
+    SQL
+
+    result = select_all(sql)
+    result.map! do |row|
+      [
+          row['ext_name'],
+          {
+              :schema_name => row['schema_name'],
+              :version => row['ext_version']
+          }
+      ]
+    end
+
+    Hash[result]
+  end
+end

data/lib/pg_power/migration/command_recorder.rb

@@ -3,10 +3,12 @@
 module PgPower::Migration::CommandRecorder
   extend ActiveSupport::Autoload
 
+  autoload :ExtensionMethods
   autoload :SchemaMethods
   autoload :CommentMethods
   autoload :ForeignerMethods
 
+  include ExtensionMethods
   include SchemaMethods
   include CommentMethods
   include ForeignerMethods

data/lib/pg_power/migration/command_recorder/extension_methods.rb

@@ -0,0 +1,25 @@
+# Provides methods to extend {ActiveRecord::Migration::CommandRecorder} to
+# support extensions feature.
+module  PgPower::Migration::CommandRecorder::ExtensionMethods
+  # :nodoc:
+  def create_extension(*args)
+    record(:create_extension, args)
+  end
+
+  # :nodoc:
+  def drop_extension(*args)
+    record(:drop_extension, args)
+  end
+
+  # :nodoc:
+  def invert_create_extension(args)
+    extension_name = args.first
+    [:drop_extension, [extension_name]]
+  end
+
+  # :nodoc:
+  def invert_drop_extension(args)
+    extension_name = args.first
+    [:create_extension, [extension_name]]
+  end
+end

data/lib/pg_power/schema_dumper.rb

@@ -5,15 +5,20 @@ module PgPower::SchemaDumper
   extend ActiveSupport::Autoload
   extend ActiveSupport::Concern
 
+  autoload :ExtensionMethods
   autoload :CommentMethods
   autoload :SchemaMethods
   autoload :ForeignerMethods
 
+  include ExtensionMethods
   include CommentMethods
   include SchemaMethods
   include ForeignerMethods
 
   included do
+    alias_method_chain :header, :schemas
+    alias_method_chain :header, :extensions
+
     alias_method_chain :tables, :schemas
     alias_method_chain :tables, :comments
     alias_method_chain :tables, :foreign_keys

data/lib/pg_power/schema_dumper/extension_methods.rb

@@ -0,0 +1,28 @@
+# Extends ActiveRecord::SchemaDumper class to dump comments on tables and columns.
+module PgPower::SchemaDumper::ExtensionMethods
+  # Hooks {ActiveRecord::SchemaDumper#header} method to dump extensions in all schemas except for pg_catalog
+  def header_with_extensions(stream)
+    header_without_extensions(stream)
+    dump_extensions(stream)
+    stream
+  end
+
+# Dump current database extensions recreation commands to the given stream
+#
+# @param [#puts] stream Stream to write to
+  def dump_extensions(stream)
+    extensions = @connection.extensions
+    commands = extensions.map do |extension_name, options|
+      result = [%Q|create_extension "#{extension_name}"|]
+      result << %Q|:schema_name => "#{options[:schema_name]}"| unless options[:schema_name] == 'public'
+      result << %Q|:version => "#{options[:version]}"|
+      result.join(', ')
+    end
+
+    commands.each do |c|
+      stream.puts("  " + c)
+    end
+
+    stream.puts
+  end
+end

data/lib/pg_power/schema_dumper/schema_methods.rb

@@ -1,11 +1,17 @@
 # Extends ActiveRecord::SchemaDumper class to dump schemas other than "public"
 # and tables from those schemas.
 module PgPower::SchemaDumper::SchemaMethods
+  # Dump create schema statements
+  def header_with_schemas(stream)
+    header_without_schemas(stream)
+    schemas(stream)
+    stream
+  end
+
   # * Dumps schemas.
   # * Dumps tables from public schema using native #tables method.
   # * Dumps tables from schemas other than public.
   def tables_with_schemas(stream)
-    schemas(stream)
     tables_without_schemas(stream)
     non_public_schema_tables(stream)
   end

data/lib/pg_power/version.rb

@@ -1,4 +1,4 @@
 module PgPower
   # Version of pg_power gem.
-  VERSION = "1.1.0"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: pg_power
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
 - Potapov Sergey
 - Arthur Shagall
+- Artem Ignatyev
 - TMX Credit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-26 00:00:00.000000000 Z
+date: 2012-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -141,8 +142,8 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ActiveRecord extensions for PostgreSQL. Provides useful tools and ability
-  to create/drop schemas in migrations.
+description: ActiveRecord extensions for PostgreSQL. Provides useful tools for schema,
+  foreign_key, index, comment and extensios manipulations in migrations.
 email:
 - rubygems@tmxcredit.com
 executables: []
@@ -166,6 +167,7 @@ files:
 - lib/pg_power/connection_adapters/index_definition.rb
 - lib/pg_power/connection_adapters/postgresql_adapter.rb
 - lib/pg_power/connection_adapters/postgresql_adapter/comment_methods.rb
+- lib/pg_power/connection_adapters/postgresql_adapter/extension_methods.rb
 - lib/pg_power/connection_adapters/postgresql_adapter/foreigner_methods.rb
 - lib/pg_power/connection_adapters/postgresql_adapter/index_methods.rb
 - lib/pg_power/connection_adapters/postgresql_adapter/schema_methods.rb
@@ -179,10 +181,12 @@ files:
 - lib/pg_power/migration.rb
 - lib/pg_power/migration/command_recorder.rb
 - lib/pg_power/migration/command_recorder/comment_methods.rb
+- lib/pg_power/migration/command_recorder/extension_methods.rb
 - lib/pg_power/migration/command_recorder/foreigner_methods.rb
 - lib/pg_power/migration/command_recorder/schema_methods.rb
 - lib/pg_power/schema_dumper.rb
 - lib/pg_power/schema_dumper/comment_methods.rb
+- lib/pg_power/schema_dumper/extension_methods.rb
 - lib/pg_power/schema_dumper/foreigner_methods.rb
 - lib/pg_power/schema_dumper/schema_methods.rb
 - lib/pg_power/tools.rb
@@ -202,7 +206,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -621483421206137072
+      hash: 3962762731367048390
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: