activerecord-postgresql-extensions 0.1.0 → 0.2.0

data/README.rdoc

@@ -29,9 +29,20 @@ PostgreSQL adapter including:
   geos-extensions gem at https://github.com/zoocasa/geos-extensions or
   the RGeo project at https://github.com/dazuma/rgeo .
 
-== First Public Release Notice!
+== Building db/schema.rb
 
-This is the first public release of this gem, so while it has been kind to us
-and our software, we can't guarantee that for everyone. That said, we do hope
-that someone out there finds it useful and enjoys the new-found powers of
-PostgreSQL!
+While this extension has support for creating a bunch of PostgreSQL-specific
+DDL statements, it can't actually reverse the process yet to create the Ruby
+equivalent code in your schema.rb file. To create a suitable schema file
+that you can use for creating test databases or just to view the schema
+itself, you can try switching the ActiveRecord configuration option for
+schema_format from :ruby to :sql like so:
+
+  config.active_record.schema_format = :sql
+
+This will tell ActiveRecord to use the pg_dump utility to create a file
+containing the database schema in db/development_structure.sql.
+
+Details on this configuration option can be found here:
+
+http://guides.rubyonrails.org/configuring.html

data/activerecord-postgresql-extensions.gemspec

@@ -28,5 +28,7 @@ Gem::Specification.new do |s|
   end
   s.add_dependency("rdoc")
   s.add_dependency("rake", ["~> 0.9"])
+  s.add_dependency("minitest")
+  s.add_dependency("turn")
 end
 

data/lib/active_record/postgresql_extensions/adapter_extensions.rb

@@ -39,7 +39,7 @@ module ActiveRecord
       # can have multiple with_schemas wrapped around each other, and
       # hopefully they won't collide with one another.
       #
-      # Examples:
+      # ==== Examples
       #
       #   # should produce '"geospatial"."my_tables"'
       #   with_schema :geospatial do
@@ -62,7 +62,7 @@ module ActiveRecord
       # When using with_schema, you can temporarily ignore the scoped
       # schemas with ignore_block.
       #
-      # Example:
+      # ==== Example
       #
       #   with_schema :geospatial do
       #     create_table(:test) do |t|
@@ -676,6 +676,18 @@ module ActiveRecord
         end
       end
       alias_method_chain :change_column_default, :expression
+
+      def change_column_null_with_expression(table_name, column_name, null, default = nil) #:nodoc:
+        if default.is_a?(Hash) && default.has_key?(:expression)
+          unless null
+            execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)} = #{default[:expression]} WHERE #{quote_column_name(column_name)} IS NULL")
+          end
+          execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
+        else
+          change_column_null_without(table_name, column_name, null, default = nil)
+        end
+      end
+      alias_method_chain :change_column_null, :expression
     end
 
     class PostgreSQLColumn

data/lib/active_record/postgresql_extensions/constraints.rb

@@ -47,11 +47,12 @@ module ActiveRecord
 
       # Adds a FOREIGN KEY constraint to the table. See
       # PostgreSQLForeignKeyConstraint for details.
-      def add_foreign_key(table, columns, ref_table, *args)
+      def add_foreign_key_constraint(table, columns, ref_table, *args)
         sql = "ALTER TABLE #{quote_table_name(table)} ADD "
         sql << PostgreSQLForeignKeyConstraint.new(self, columns, ref_table, *args).to_s
         execute("#{sql};")
       end
+      alias :add_foreign_key :add_foreign_key_constraint
 
       # Adds an EXCLUDE constraint to the table. See
       # PostgreSQLExcludeConstraint for details.
@@ -61,6 +62,15 @@ module ActiveRecord
         execute("#{sql};")
       end
 
+      # Adds a PRIMARY KEY constraint to the table. See
+      # PostgreSQLPrimaryKeyConstraint for details.
+      def add_primary_key_constraint(table, columns, options = {})
+        sql = "ALTER TABLE #{quote_table_name(table)} ADD "
+        sql << PostgreSQLPrimaryKeyConstraint.new(self, columns, options).to_s
+        execute("#{sql};")
+      end
+      alias :add_primary_key :add_primary_key_constraint
+
       # Drops a constraint from the table. Use this to drop CHECK,
       # UNIQUE, EXCLUDE and FOREIGN KEY constraints from a table.
       #
@@ -73,6 +83,12 @@ module ActiveRecord
         sql << ' CASCADE' if options[:cascade]
         execute("#{sql};")
       end
+
+      # Validates a constraint and removes the NOT VALID clause from its
+      # definition.
+      def validate_constraint(table, name)
+        execute("ALTER TABLE #{quote_table_name(table)} VALIDATE CONSTRAINT #{quote_generic(name)};")
+      end
     end
 
     # This is a base class for other PostgreSQL constraint classes. It
@@ -110,6 +126,39 @@ module ActiveRecord
             "CONSTRAINT #{base.quote_generic(options[:name])} "
           end
         end
+
+        def storage_parameters
+          if options[:index_parameters] || options[:storage_parameters]
+            " WITH (#{options[:index_parameters] || options[:storage_parameters]})"
+          else
+            ''
+          end
+        end
+        alias :index_parameters :storage_parameters
+
+        def using_tablespace
+          if options[:tablespace]
+            " USING INDEX TABLESPACE #{base.quote_tablespace(options[:tablespace])}"
+          else
+            ''
+          end
+        end
+
+        def not_valid
+          if options[:not_valid]
+            " NOT VALID"
+          else
+            ''
+          end
+        end
+
+        def no_inherit
+          if options[:no_inherit]
+            " NO INHERIT"
+          else
+            ''
+          end
+        end
     end
 
     # Creates CHECK constraints for PostgreSQL tables.
@@ -216,6 +265,9 @@ module ActiveRecord
     # * <tt>:expression</tt> - when creating a column definition, you can
     #   supply either a String containing the expression or a Hash to
     #   supply both <tt>:name</tt> and <tt>:expression</tt> values.
+    # * <tt>:not_valid</tt> - adds the NOT VALID clause. Only useful when
+    #   altering an existing table.
+    # * <tt>:no_inherit</tt> - adds the NO INHERIT clause.
     #
     # === Dropping CHECK Constraints
     #
@@ -231,7 +283,7 @@ module ActiveRecord
       end
 
       def to_sql #:nodoc:
-        "#{constraint_name}CHECK (#{expression})"
+        "#{constraint_name}CHECK (#{expression})#{not_valid}#{no_inherit}"
       end
       alias :to_s :to_sql
     end
@@ -259,7 +311,7 @@ module ActiveRecord
     # can specify UNIQUE constraints on individual columns during
     # definition.
     #
-    # ==== Example:
+    # ==== Example
     #
     #   create_table(:foo) do |t|
     #     t.integer :fancy_id, :unique => true
@@ -283,7 +335,7 @@ module ActiveRecord
     # than on a column definition. This is useful when you want to add
     # multiple columns to the constraint.
     #
-    # ==== Example:
+    # ==== Example
     #
     #   create_table(:foo) do |t|
     #     t.integer :fancy_id
@@ -340,8 +392,7 @@ module ActiveRecord
     # or when using add_unique_constraint, there are a hanful of
     # PostgreSQL-specific options that you may find useful.
     #
-    # * <tt>:name</tt> - specify a name for the index created by the
-    #   UNIQUE constraint.
+    # * <tt>:name</tt> - specifies a name for the constraint.
     # * <tt>:storage_parameters</tt> - PostgreSQL allows you to add a
     #   couple of additional parameters to indexes to govern disk usage and
     #   such. This option is a simple String that lets you insert these
@@ -375,8 +426,8 @@ module ActiveRecord
         sql = "#{constraint_name}UNIQUE ("
         sql << Array(columns).collect { |c| base.quote_column_name(c) }.join(', ')
         sql << ")"
-        sql << " WITH (#{options[:storage_parameters] || options[:index_parameters]})" if options[:storage_parameters] || options[:index_parameters]
-        sql << " USING INDEX TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
+        sql << storage_parameters
+        sql << using_tablespace
         sql
       end
       alias :to_s :to_sql
@@ -398,7 +449,7 @@ module ActiveRecord
     # can specify FOREIGN KEY constraints on individual columns during
     # definition.
     #
-    # ==== Example:
+    # ==== Example
     #
     #   create_table(:foo) do |t|
     #     t.integer :bar_id, :references => { :table => :bar, :column => :id }
@@ -426,7 +477,7 @@ module ActiveRecord
     # FOREIGN KEY constraints can also be applied to the table directly
     # rather than on a column definition.
     #
-    # ==== Example:
+    # ==== Example
     #
     # The following example produces the same result as above:
     #
@@ -512,6 +563,8 @@ module ActiveRecord
     #   values are <tt>:no_action</tt>, <tt>:restrict</tt>,
     #   <tt>:cascade</tt>, <tt>:set_null</tt> and <tt>:set_default</tt>.
     #   PostgreSQL's default is <tt>:no_action</tt>.
+    # * <tt>:not_valid</tt> - adds the NOT VALID clause. Only useful when
+    #   altering an existing table.
     #
     # See the PostgreSQL documentation on foreign keys for details about
     # the <tt>:deferrable</tt>, <tt>:match</tt>, <tt>:on_delete</tt>
@@ -554,6 +607,7 @@ module ActiveRecord
           sql << " MATCH #{options[:match].to_s.upcase}" if options[:match]
           sql << " ON DELETE #{options[:on_delete].to_s.gsub(/_/, ' ').upcase}" if options[:on_delete]
           sql << " ON UPDATE #{options[:on_update].to_s.gsub(/_/, ' ').upcase}" if options[:on_update]
+          sql << not_valid
           sql << deferrable
         end
         sql
@@ -597,7 +651,7 @@ module ActiveRecord
     # EXCLUDE constraints can also be applied to the table directly
     # rather than on a column definition.
     #
-    # ==== Example:
+    # ==== Example
     #
     # The following example produces the same result as above:
     #
@@ -631,6 +685,7 @@ module ActiveRecord
     #
     # === Options for EXCLUDE Constraints
     #
+    # * <tt>:name</tt> - specifies a name for the constraint.
     # * <tt>:using</tt> - sets the index type to be used. Usually this will
     #   <tt>:gist</tt>, but the default is left blank to allow for the PostgreSQL
     #   default which is <tt>:btree</tt>. See the PostgreSQL docs for details.
@@ -668,12 +723,147 @@ module ActiveRecord
           "#{e[:element]} WITH #{e[:with] || e[:operator]}"
         }.join(', ')
         sql << ")"
-        sql << " WITH (#{options[:index_parameters] || options[:storage_parameters]})" if options[:index_parameters] || options[:storage_parameters]
-        sql << " USING INDEX TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
+        sql << storage_parameters
+        sql << using_tablespace
         sql << " WHERE (#{options[:conditions] || options[:where]})" if options[:conditions] || options[:where]
         sql
       end
       alias :to_s :to_sql
     end
+
+    # Creates PRIMARY KEY constraints for PostgreSQL tables and columns.
+    #
+    # This class is meant to be used by PostgreSQL column and table
+    # definition and manipulation methods. There are several ways to create
+    # a PRIMARY KEY constraint:
+    #
+    # * on a table definition
+    # * on a column definition
+    # * when altering a table
+    #
+    # ActiveRecord itself already provides some methods of creating PRIMARY
+    # KEYS, but we've added some PostgreSQL-specific extensions here. To
+    # override ActiveRecord's built-in PRIMARY KEY generation, add an
+    # option for <tt>:id => false</tt> when creating the table via
+    # <tt>create_table</tt>.
+    #
+    # When creating PRIMARY KEYs, you can use an options Hash to add various
+    # PostgreSQL-specific options as necessary or simply use a true statement
+    # to create a PRIMARY KEY on the column. Composite PRIMARY KEYs can also
+    # be created across multiple columns using a table definition or the
+    # PostgreSQLAdapter#add_primary_key method.
+    #
+    # === Column Definition
+    #
+    # When creating a new table via PostgreSQLAdapter#create_table, you
+    # can specify PRIMARY KEY constraints on individual columns during
+    # definition.
+    #
+    # ==== Examples
+    #
+    #   create_table(:foo, :id => false) do |t|
+    #     t.integer :foo_id, :primary_key => true
+    #   end
+    #
+    #   # Produces:
+    #   # CREATE TABLE "foo" (
+    #   #   "foo_id" integer,
+    #   #   PRIMARY KEY ("foo_id")
+    #   # );
+    #
+    #   create_table('foo', :id => false) do |t|
+    #     t.integer :foo_id, :primary_key => {
+    #       :tablespace => 'fubar',
+    #       :index_parameters => 'FILLFACTOR=10'
+    #     }
+    #   end
+    #
+    #   # Produces:
+    #   # CREATE TABLE "foo" (
+    #   #   "foo_id" integer,
+    #   #   PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+    #   # );
+    #
+    # === Table Definition
+    #
+    # PRIMARY KEY constraints can also be applied to the table directly
+    # rather than on a column definition.
+    #
+    # ==== Examples
+    #
+    # The following examples produces the same results as above:
+    #
+    #   create_table('foo', :id => false) do |t|
+    #     t.integer :foo_id
+    #     t.primary_key_constraint :foo_id
+    #   end
+    #
+    #   create_table('foo', :id => false) do |t|
+    #     t.integer :foo_id
+    #     t.primary_key_constraint :foo_id, {
+    #       :tablespace => 'fubar',
+    #       :index_parameters => 'FILLFACTOR=10'
+    #     }
+    #   end
+    #
+    # === Table Manipulation
+    #
+    # You can also create new PRIMARY KEY constraints outside of a table
+    # definition using PostgreSQLAdapter#add_primary_key or
+    # PostgreSQLAdapter#add_primary_key_constraint.
+    #
+    # ==== Examples
+    #
+    #   add_primary_key(:foo, :bar_id)
+    #   add_primary_key(:foo, [ :bar_id, :baz_id ])
+    #   add_primary_key(:foo, :bar_id, :name => 'foo_pk')
+    #   add_primary_key(:foo, :bar_id, :tablespace => 'fubar', :index_parameters => 'FILLFACTOR=10')
+    #
+    #   # Produces:
+    #   # ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id");
+    #   # ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id", "baz_id");
+    #   # ALTER TABLE "foo" ADD CONSTRAINT "foo_pk" PRIMARY KEY ("bar_id");
+    #   # ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";
+    #
+    # === Options for PRIMARY KEY Constraints
+    #
+    # * <tt>:name</tt> - specifies a name for the constraint.
+    # * <tt>:storage_parameters</tt> - PostgreSQL allows you to add a
+    #   couple of additional parameters to indexes to govern disk usage and
+    #   such. This option is a simple String that lets you insert these
+    #   options as necessary. See the PostgreSQL documentation on index
+    #   storage parameters for details. <tt>:index_parameters</tt> can also
+    #   be used.
+    # * <tt>:tablespace</tt> - allows you to specify a tablespace for the
+    #   index being created. See the PostgreSQL documentation on
+    #   tablespaces for details.
+    #
+    # === Dropping PRIMARY KEY Constraints
+    #
+    # Like all PostgreSQL constraints, you can use
+    # PostgreSQLAdapter#drop_constraint to remove a constraint from a
+    # table.
+    class PostgreSQLPrimaryKeyConstraint < PostgreSQLConstraint
+      attr_accessor :columns
+
+      def initialize(base, columns, options = {}) #:nodoc:
+        @columns = columns
+
+        super(base, options)
+      end
+
+      def to_sql #:nodoc:
+        sql = String.new
+        sql << "#{constraint_name}PRIMARY KEY "
+        sql << "(" << Array(columns).collect { |column|
+          base.quote_column_name(column)
+        }.join(', ')
+        sql << ")"
+        sql << storage_parameters
+        sql << using_tablespace
+        sql
+      end
+      alias :to_s :to_sql
+    end
   end
 end

data/lib/active_record/postgresql_extensions/extensions.rb

@@ -8,6 +8,9 @@ module ActiveRecord
       # either a parser_name or a source_config option as per the PostgreSQL
       # text search docs.
       def create_extension(name, options = {})
+        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
+          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
         sql = "CREATE EXTENSION "
         sql << "IF NOT EXISTS " if options[:if_not_exists]
         sql << quote_generic(name)
@@ -23,6 +26,9 @@ module ActiveRecord
       # * <tt>if_exists</tt> - adds IF EXISTS.
       # * <tt>cascade</tt> - adds CASCADE.
       def drop_extension(*args)
+        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
+          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
         options = args.extract_options!
 
         sql = 'DROP EXTENSION '
@@ -34,12 +40,18 @@ module ActiveRecord
       end
 
       def update_extension(name, new_version = nil)
+        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
+          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
         sql = "ALTER EXTENSION #{quote_generic(name)} UPDATE"
         sql << " TO #{quote_generic(new_version)}" if new_version;
         execute("#{sql};")
       end
 
       def alter_extension_schema(name, schema)
+        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
+          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
         execute "ALTER EXTENSION #{quote_generic(name)} SET SCHEMA #{quote_schema(schema)};"
       end
 
@@ -112,6 +124,9 @@ module ActiveRecord
       # * <tt>:operator_class</tt> and <tt>:operator_family</tt> - <tt>:name</tt>
       #   and <tt>:indexing_method</tt>.
       def alter_extension(name, options = {})
+        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
+          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
         alterer = PostgreSQLExtensionAlterer.new(self, name, options)
 
         if block_given?
@@ -124,6 +139,9 @@ module ActiveRecord
 
     class PostgreSQLExtensionAlterer
       def initialize(base, name, options = {}) #:nodoc:
+        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
+          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
         @base, @name, @options = base, name, options
         @sql = options.collect { |k, v| build_statement(k, v) }
       end