activerecord-postgresql-extensions 0.0.7

data/lib/postgresql_extensions/postgresql_rules.rb

@@ -0,0 +1,112 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  class InvalidRuleEvent < ActiveRecordError #:nodoc:
+    def initialize(event)
+      super("Invalid rule event - #{event}")
+    end
+  end
+
+  class InvalidRuleAction < ActiveRecordError #:nodoc:
+    def initialize(action)
+      super("Invalid rule action - #{action}")
+    end
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a PostgreSQL rule.
+      #
+      # +event+ can be one of <tt>:select</tt>, <tt>:insert</tt>,
+      # <tt>:update</tt> or <tt>:delete</tt>.
+      #
+      # +action+ can be one of <tt>:instead</tt> or <tt>:also</tt>.
+      #
+      # +commands+ is the actual query to rewrite to. commands can
+      # actually be "+NOTHING+", a String representing the commands
+      # or an Array of Strings if you have multiple commands you want to
+      # fire.
+      #
+      # ==== Options
+      #
+      # * <tt>:force</tt> - add an <tt>OR REPLACE</tt> clause to the
+      #   command.
+      # * <tt>:conditions</tt> - a <tt>WHERE</tt> clause to limit the
+      #   rule.
+      #
+      # ==== Examples
+      #
+      #  ### ruby
+      #  create_rule(
+      #    'check_it_out_rule',
+      #    :select,
+      #    :child,
+      #    :instead,
+      #    'select * from public.another', :conditions => 'id = 1'
+      #  )
+      #  # => CREATE RULE "check_it_out_rule" AS ON SELECT TO "child" WHERE id = 1 DO INSTEAD select * from public.another;
+      def create_rule(name, event, table, action, commands, options = {})
+        execute PostgreSQLRuleDefinition.new(self, name, event, table, action, commands, options).to_s
+      end
+
+      # Drops a PostgreSQL rule.
+      def drop_rule(name, table)
+        execute "DROP RULE #{quote_rule(name)} ON #{quote_table_name(table)}"
+      end
+    end
+
+    # Creates a PostgreSQL rule.
+    #
+    # The PostgreSQL rule system is basically a query-rewriter. You should
+    # take a look at the PostgreSQL documentation for more details, but the
+    # basic idea is that a rule can be set to fire on certain query events
+    # and will force the query to be rewritten before it is even sent to
+    # the query planner and executor.
+    #
+    # Generally speaking, you're probably going to want to stick to
+    # create_rule and drop_rule when working with rules.
+    class PostgreSQLRuleDefinition
+      attr_accessor :base, :name, :event, :table, :action, :commands, :options
+
+      def initialize(base, name, event, table, action, commands, options = {}) #:nodoc:
+        assert_valid_event(event)
+        assert_valid_action(action)
+        @base, @name, @event, @table, @action, @commands, @options =
+          base, name, event, table, action, commands, options
+      end
+
+      def to_sql #:nodoc:
+        sql = 'CREATE '
+        sql << ' OR REPLACE ' if options[:force]
+        sql << "RULE #{base.quote_rule(name)} AS ON #{event.to_s.upcase} TO #{base.quote_table_name(table)} "
+        sql << "WHERE #{options[:conditions]} " if options[:conditions]
+        sql << "DO #{action.to_s.upcase} "
+        sql << if commands.to_s.upcase == 'NOTHING'
+          'NOTHING'
+        elsif commands.is_a?(Array)
+          '(' << commands.collect(&:to_s).join(';') << ')'
+        else
+          commands.to_s
+        end
+      end
+      alias :to_s :to_sql
+
+      private
+        EVENTS = [ 'select', 'insert', 'update', 'delete' ].freeze
+        ACTIONS = [ 'instead', 'also' ].freeze
+
+        def assert_valid_event(event) #:nodoc:
+          if !EVENTS.include? event.to_s
+            raise ActiveRecord::InvalidRuleEvent.new(event)
+          end
+        end
+
+        def assert_valid_action(action) #:nodoc:
+          if !ACTIONS.include? action.to_s
+            raise ActiveRecord::InvalidRuleAction.new(action)
+          end
+        end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_schemas.rb

@@ -0,0 +1,49 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a new PostgreSQL schema.
+      #
+      # Note that you can grant privileges on schemas using the
+      # grant_schema_privileges method and revoke them using
+      # revoke_schema_privileges.
+      #
+      # ==== Options
+      #
+      # * <tt>:authorization</tt> - adds an AUTHORIZATION clause. This is
+      #   used to set the owner of the schema. This can be changed with
+      #   alter_schema_owner as necessary.
+      def create_schema schema, options = {}
+        sql = "CREATE SCHEMA #{quote_schema(schema)}"
+        sql << " AUTHORIZATION #{quote_role(options[:authorization])}" if options[:authorization]
+        execute sql
+      end
+
+      # Drops a schema.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_schema schemas, options = {}
+        sql = 'DROP SCHEMA '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array(schemas).collect { |s| quote_schema(s) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      # Alter's a schema's name.
+      def alter_schema_name old_schema, new_schema
+        execute "ALTER SCHEMA #{quote_schema(old_schema)} RENAME TO #{quote_schema(new_schema)}"
+      end
+
+      # Changes a schema's owner.
+      def alter_schema_owner schema, role
+        execute "ALTER SCHEMA #{quote_schema(schema)} OWNER TO #{quote_schema(role)}"
+      end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_sequences.rb

@@ -0,0 +1,222 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  class InvalidSequenceAction < ActiveRecordError #:nodoc:
+    def initialize(action)
+      super("Invalid sequence action - #{action}")
+    end
+  end
+
+  class InvalidSequenceOptions < ActiveRecordError #:nodoc:
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a sequence.
+      #
+      # Note that you can grant privileges on sequences using the
+      # grant_sequence_privileges method and revoke them using
+      # revoke_sequence_privileges.
+      #
+      # ==== Options
+      #
+      # * <tt>:temporary</tt> - creates a temporary sequence.
+      # * <tt>:incement</tt> - sets the sequence increment value.
+      # * <tt>:min_value</tt> - sets a minimum value for the sequence.
+      #   If this value is <tt>nil</tt> or <tt>false</tt>, we'll go with
+      #   "NO MINVALUE".
+      # * <tt>:max_value</tt> - same as <tt>:min_value</tt> but for
+      #   maximum values. Mindblowing.
+      # * <tt>:start</tt> - the initial value of the sequence.
+      # * <tt>:cache</tt> - the number of future values to cache in
+      #   the sequence. This is generally dangerous to mess with, so be
+      #   sure to refer to the PostgreSQL documentation for reasons why.
+      # * <tt>:cycle</tt> - whether or not the sequence should cycle.
+      # * <tt>:owned_by</tt> - this refers to the table and column that
+      #   a sequence is owned by. If that column/table were to be
+      #   dropped in the future, for instance, the sequence would be
+      #   automatically dropped with it. This option can be set using
+      #   an Array (as in <tt>[ table, column ]</tt>) or a Hash
+      #   (as in <tt>{ :table => 'foo', :column => 'bar' }</tt>).
+      #
+      # ==== Example
+      #
+      #  ### ruby
+      #  create_sequence(
+      #    'what_a_sequence_of_events',
+      #    :increment => 2,
+      #    :cache => 2,
+      #    :min_value => nil,
+      #    :max_value => 10,
+      #    :owned_by => [ :foo, :id ]
+      #  )
+      #  # => CREATE SEQUENCE "what_a_sequence_of_events" INCREMENT BY 2
+      #  #    NO MINVALUE MAXVALUE 10 CACHE 2 OWNED BY "foo"."id";
+      def create_sequence(name, options = {})
+        execute PostgreSQLSequenceDefinition.new(self, :create, name, options).to_s
+      end
+
+      # Drops a sequence.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - cascades the operation down to objects
+      #   referring to the sequence.
+      def drop_sequence(name, options = {})
+        sql = 'DROP SEQUENCE '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array(name).collect { |s| quote_sequence(s) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      # Renames the sequence.
+      def rename_sequence(name, rename, options = {})
+        execute "ALTER SEQUENCE #{quote_sequence(name)} RENAME TO #{quote_generic_ignore_schema(rename)}"
+      end
+
+      # Alters the sequence's schema.
+      def alter_sequence_schema(name, schema, options = {})
+        execute "ALTER SEQUENCE #{quote_sequence(name)} SET SCHEMA #{quote_schema(schema)}"
+      end
+
+      # Alters any of the various options for a sequence. See
+      # create_sequence for details on the available options. In addition
+      # to the options provided by create_sequence, there is also the
+      # <tt>:restart_with</tt> option, which resets the sequence to
+      # a new starting value and sets the <tt>is_called</tt> flag to
+      # false, which would be the equivalent of calling the PostgreSQL
+      # function <tt>setval</tt> with a false value in the third
+      # parameter.
+      def alter_sequence(name, options = {})
+        execute PostgreSQLSequenceDefinition.new(self, :alter, name, options).to_s
+      end
+
+      # Calls the <tt>setval</tt> function on the sequence.
+      #
+      # ==== Options
+      #
+      # * <tt>:is_called</tt> - the value to set in the third argument
+      #   to the function call, which is, appropriately enough, the
+      #   <tt>is_called</tt> argument. The default value is true.
+      def set_sequence_value(name, value, options = {})
+        options = {
+          :is_called => true
+        }.merge(options)
+
+        execute "SELECT setval(#{quote(name)}, #{value.to_i}, " <<
+          if options[:is_called]
+            'true'
+          else
+            'false'
+          end <<
+          ')'
+      end
+
+      # Returns an Array of available sequences.
+      def sequences(name = nil)
+        query(<<-SQL, name).map { |row| row[0] }
+          SELECT c.relname AS sequencename
+          FROM pg_class c
+          WHERE c.relkind = 'S'::"char";
+        SQL
+      end
+
+      def sequence_exists?(name)
+        sequences.include?(name.to_s)
+      end
+    end
+
+    # Class used to create or alter sequences. Generally you should be
+    # using PostgreSQLAdapter#create_sequence and its various sequence
+    # manipulation functions rather than using this class directly.
+    class PostgreSQLSequenceDefinition
+      attr_accessor :base, :action, :name, :options
+
+      def initialize(base, action, name, options = {}) #:nodoc:
+        assert_valid_owned_by(options)
+        assert_valid_action(action)
+
+        @base, @action, @name, @options = base, action, name, options
+      end
+
+      def to_sql #:nodoc:
+        sql = Array.new
+        if action == :create
+          sql << 'CREATE'
+          sql << 'TEMPORARY' if options[:temporary]
+        else
+          sql << 'ALTER'
+        end
+        sql << "SEQUENCE #{base.quote_sequence(name)}"
+        sql << "INCREMENT BY #{options[:increment].to_i}" if options[:increment]
+        if options.has_key?(:min_value)
+          sql << case options[:min_value]
+            when NilClass, FalseClass
+              'NO MINVALUE'
+            else
+              "MINVALUE #{options[:min_value].to_i}"
+          end
+        end
+
+        if options.has_key?(:max_value)
+          sql << case options[:max_value]
+            when NilClass, FalseClass
+              'NO MAXVALUE'
+            else
+              "MAXVALUE #{options[:max_value].to_i}"
+          end
+        end
+        sql << "START WITH #{options[:start].to_i}" if options[:start]
+        sql << "CACHE #{options[:cache].to_i}" if options[:cache]
+
+        if options.has_key?(:cycle)
+          sql << (options[:cycle] ? 'CYCLE' : 'NO CYCLE')
+        end
+
+        if options.has_key?(:owned_by)
+          table_column = if options[:owned_by].is_a?(Hash)
+            [ options[:owned_by][:table], options[:owned_by][:column] ]
+          elsif options[:owned_by].is_a?(Array)
+            options[:owned_by]
+          end
+
+          sql << 'OWNED BY ' + if options[:owned_by] == :none
+            'NONE'
+          else
+            "#{base.quote_table_name(table_column.first)}.#{base.quote_column_name(table_column.last)}"
+          end
+        end
+
+        if action != :create && options.has_key?(:restart_with)
+          sql << "RESTART WITH #{options[:restart_with].to_i}"
+        end
+        sql.join(' ')
+      end
+      alias :to_s :to_sql
+
+      private
+        def assert_valid_owned_by(options) #:nodoc:
+          if options.has_key?(:owned_by)
+            begin
+              if options[:owned_by].is_a?(Hash)
+                raise if !(options[:owned_by].keys.sort == [ :column, :table ])
+              elsif options[:owned_by].is_a?(Array)
+                raise if options[:owned_by].length != 2
+              end
+            rescue
+              raise ActiveRecord::InvalidSequenceOptions.new("Invalid :owned_by options")
+            end
+          end
+        end
+
+        def assert_valid_action(action) #:nodoc:
+          if ![ :create, :alter ].include?(action)
+            raise ActiveRecord::InvalidSequenceAction.new(action)
+          end
+        end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_tables.rb

@@ -0,0 +1,308 @@
+
+module ActiveRecord
+  class InvalidLikeTypes < ActiveRecordError #:nodoc:
+    def initialize(likes)
+      super("Invalid LIKE INCLUDING/EXCLUDING types - #{likes.inspect}")
+    end
+  end
+
+  class InvalidTableOptions < ActiveRecordError #:nodoc:
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Set the schema of a table.
+      def alter_table_schema table_name, schema, options = {}
+        execute "ALTER TABLE #{quote_schema(table_name)} SET SCHEMA #{quote_schema(schema)}"
+      end
+
+      alias :original_create_table :create_table
+      # Creates a new table. We've expanded the capabilities of the
+      # standard ActiveRecord create_table method to included a host of
+      # PostgreSQL-specific functionality.
+      #
+      # === PostgreSQL-specific Do-dads
+      #
+      # PostgreSQL allows for a couple of nifty table creation options
+      # that ActiveRecord usually doesn't account for, so we're filling
+      # in the blanks here.
+      #
+      # * <tt>:inherits</tt> - PostgreSQL allows you to create tables
+      #   that inherit the properties of another. PostgreSQL is
+      #   sometimes referred to as an Object-Relational DBMS rather
+      #   than a straight-up RDBMS because of stuff like this.
+      # * <tt>:on_commit</tt> - allows you to define the behaviour of
+      #   temporary tables. Allowed values are <tt>:preserve_rows</tt>
+      #   (the default, which causes the temporary table to retain its
+      #   rows at the end of a transaction), <tt>:delete_rows</tt>
+      #   (which truncates the table at the end of a transaction) and
+      #   <tt>:drop</tt> (which drops the table at the end of a
+      #   transaction).
+      # * <tt>:tablespace</tt> - allows you to set the tablespace of a
+      #   table.
+      # * <tt>:force</tt> - force a table to be dropped before trying to
+      #   create it. This will pass <tt>:if_exists => true</tt> to the
+      #   drop_table method.
+      # * <tt>:cascade_drop</tt> - when using the <tt>:force</tt>, this
+      #   Jedi mindtrick will pass along the :cascade option to
+      #   drop_table.
+      #
+      # We're expanding the doors of table definition perception with
+      # this exciting new addition to the world of ActiveRecord
+      # PostgreSQL adapters.
+      #
+      # create_table generally behaves like the standard ActiveRecord
+      # create_table method with a couple of notable exceptions:
+      #
+      # * you can add column constraints.
+      # * you can add constraints to the table itself.
+      # * you can add LIKE and INHERITS clauses to the definition.
+      #
+      # See the PostgreSQL documentation for more detailed on these
+      # sorts of things. Odds are that you'll probably recognize what
+      # we're referring to here if you're bothering to use this
+      # plugin, eh?
+      #
+      # Also, do note that you can grant privileges on tables using the
+      # grant_table_privileges method and revoke them using
+      # revoke_table_privileges.
+      #
+      # ==== Examples
+      #
+      #  ### ruby
+      #  create_table(:foo, :inherits => :parent) do |t|
+      #    t.integer :bar_id, :references => :bar
+      #    t.like :base, :including => [ :defaults, :indexes ], :excluding => :constraints
+      #    t.check_constraint "bar_id < 100"
+      #    t.unique_constraint :bar_id
+      #  end
+      #
+      #  # Produces:
+      #  #
+      #  # CREATE TABLE "foo" (
+      #  #   "id" serial primary key,
+      #  #   "bar_id" integer DEFAULT NULL NULL,
+      #  #   LIKE "base" INCLUDING DEFAULTS INCLUDING INDEXES EXCLUDING CONSTRAINTS,
+      #  #   FOREIGN KEY ("bar_id") REFERENCES "bar",
+      #  #   CHECK (bar_id < 100),
+      #  #   UNIQUE ("bar_id")
+      #  # ) INHERITS ("parent");
+      #
+      # This is a fairly convoluted example, but there you have it.
+      #
+      # Beyond these differences, create_table acts like the original
+      # ActiveRecord create_table, which you can actually still access
+      # using the original_create_table method if you really, really want
+      # to.
+      #
+      # Be sure to refer to the PostgreSQL documentation for details on
+      # data definition and such.
+      def create_table(table_name, options = {})
+        if options[:force]
+          drop_table(table_name, { :if_exists => true, :cascade => options[:cascade_drop] })
+        end
+
+        table_definition = PostgreSQLTableDefinition.new(self, table_name, options)
+        yield table_definition
+
+        execute table_definition.to_s
+        unless table_definition.post_processing.blank?
+          table_definition.post_processing.each do |pp|
+            execute pp
+          end
+        end
+      end
+
+      alias :original_drop_table :drop_table
+      # Drops a table. This method is expanded beyond the standard
+      # ActiveRecord drop_table method to allow for a couple of
+      # PostgreSQL-specific options:
+      #
+      # * <tt>:if_exists</tt> - adds an IF EXISTS clause to the query.
+      #   In absence of this option, an exception will be raised if you
+      #   try to drop a table that doesn't exist.
+      # * <tt>:cascade</tt> - adds a CASCADE clause to the query. This
+      #   will cause references to this table like foreign keys to be
+      #   dropped as well. See the PostgreSQL documentation for details.
+      #
+      # You can still access the original method via original_drop_table.
+      def drop_table(tables, options = {})
+        sql = 'DROP TABLE '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array(tables).collect { |t| quote_table_name(t) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      alias :original_rename_table :rename_table
+      # Renames a table. We're overriding the original rename_table so
+      # that we can take advantage of our super schema quoting
+      # capabilities. You can still access the original method via
+      # original_rename_table.
+      def rename_table(name, new_name, options = {})
+        execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_generic_ignore_schema(new_name)}"
+      end
+
+      private
+        ON_COMMIT_VALUES = [ 'preserve_rows', 'delete_rows', 'drop' ].freeze
+
+        def assert_valid_on_commit(temp, on_commit)
+          unless on_commit.nil?
+            if !ON_COMMIT_VALUES.include?(on_commit.to_s.downcase)
+              raise ActiveRecord::InvalidTableOptions.new("Invalid ON COMMIT value - #{on_commit}")
+            elsif !temp
+              raise ActiveRecord::InvalidTableOptions.new("ON COMMIT can only be used with temporary tables")
+            end
+          end
+        end
+    end
+
+    # Creates a PostgreSQL table definition. This class isn't really meant
+    # to be used directly. Instead, see PostgreSQLAdapter#create_table
+    # for usage.
+    #
+    # Beyond our various PostgreSQL-specific extensions, we've also added
+    # the <tt>post_processing</tt> member, which allows you to tack on
+    # some SQL statements to run after creating the table. This member
+    # should be an Array of SQL statements to run once the table has
+    # been created. See the source code for PostgreSQLAdapter#create_table
+    # and PostgreSQLTableDefinition#geometry for an example of its use.
+    class PostgreSQLTableDefinition < TableDefinition
+      attr_accessor :base, :table_name, :options, :post_processing
+
+      def initialize(base, table_name, options = {}) #:nodoc:
+        @table_constraints = Array.new
+        @table_name, @options = table_name, options
+        super(base)
+
+        self.primary_key(
+          options[:primary_key] || Base.get_primary_key(table_name)
+        ) unless options[:id] == false
+      end
+
+      def to_sql #:nodoc:
+        sql = 'CREATE '
+        sql << 'TEMPORARY ' if options[:temporary]
+        sql << "TABLE #{base.quote_table_name(table_name)} (\n  "
+
+        ary = @columns.collect(&:to_sql)
+        ary << @like if @like
+        ary << @table_constraints unless @table_constraints.empty?
+        sql << ary * ",\n  "
+        sql << "\n)"
+
+        sql << "INHERITS (" << Array(options[:inherits]).collect { |i| base.quote_table_name(i) }.join(', ') << ')' if options[:inherits]
+        sql << "ON COMMIT #{options[:on_commit].to_s.upcase}" if options[:on_commit]
+        sql << "#{options[:options]}" if options[:options]
+        sql << "TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
+        sql
+      end
+      alias :to_s :to_sql
+
+      # Creates a LIKE statement for use in a table definition.
+      #
+      # ==== Options
+      #
+      # * <tt>:including</tt> and <tt>:excluding</tt> - set options for
+      #   the INCLUDING and EXCLUDING clauses in a LIKE statement. Valid
+      #   values are <tt>:constraints</tt>, <tt>:defaults</tt> and
+      #   <tt>:indexes</tt>. You can set one or more by using an Array.
+      #
+      # See the PostgreSQL documentation for details on how to use
+      # LIKE. Be sure to take note as to how it differs from INHERITS.
+      #
+      # Also, be sure to note that, like, this LIKE isn't, like, the
+      # LIKE you use in a WHERE condition. This is, PostgreSQL's
+      # own special LIKE clause for table definitions. Like.
+      def like(parent_table, options = {})
+        assert_valid_like_types(options[:includes])
+        assert_valid_like_types(options[:excludes])
+
+        # Huh? Whyfor I dun this?
+        # @like = base.with_schema(@schema) { "LIKE #{base.quote_table_name(parent_table)}" }
+        @like = "LIKE #{@base.quote_table_name(parent_table)}"
+
+        if options[:including]
+          @like << Array(options[:including]).collect { |l| " INCLUDING #{l.to_s.upcase}" }.join
+        end
+
+        if options[:excluding]
+          @like << Array(options[:excluding]).collect { |l| " EXCLUDING #{l.to_s.upcase}" }.join
+        end
+        @like
+      end
+
+      # Add a CHECK constraint to the table. See
+      # PostgreSQLCheckConstraint for more details.
+      def check_constraint(expression, options = {})
+        @table_constraints << PostgreSQLCheckConstraint.new(@base, expression, options)
+      end
+
+      # Add a UNIQUE constraint to the table. See
+      # PostgreSQLUniqueConstraint for more details.
+      def unique_constraint(columns, options = {})
+        @table_constraints << PostgreSQLUniqueConstraint.new(@base, columns, options)
+      end
+
+      # Add a FOREIGN KEY constraint to the table. See
+      # PostgreSQLForeignKeyConstraint for more details.
+      def foreign_key(columns, ref_table, *args)
+        @table_constraints << PostgreSQLForeignKeyConstraint.new(@base, columns, ref_table, *args)
+      end
+
+      def column_with_constraints(name, type, *args) #:nodoc:
+        options = args.extract_options!
+        check = options.delete(:check)
+        references = options.delete(:references)
+        unique = options.delete(:unique)
+        column_without_constraints(name, type, options)
+
+        if check
+          @table_constraints << Array(check).collect do |c|
+            if c.is_a?(Hash)
+              PostgreSQLCheckConstraint.new(@base, c.delete(:expression), c)
+            else
+              PostgreSQLCheckConstraint.new(@base, c)
+            end
+          end
+        end
+
+        if references
+          ref_table, ref_options = if references.is_a?(Hash)
+            [ references.delete(:table), references ]
+          else
+            [ references, {} ]
+          end
+
+          @table_constraints << PostgreSQLForeignKeyConstraint.new(
+            @base,
+            name,
+            ref_table,
+            ref_options
+          )
+        end
+
+        if unique
+          unless unique.is_a?(Hash)
+            unique = {}
+          end
+          @table_constraints << PostgreSQLUniqueConstraint.new(@base, name, unique)
+        end
+        self
+      end
+      alias_method_chain :column, :constraints
+
+      private
+        LIKE_TYPES = [ 'defaults', 'constraints', 'indexes' ].freeze
+
+        def assert_valid_like_types(likes) #:nodoc:
+          unless likes.blank?
+            check_likes = Array(likes).collect(&:to_s) - LIKE_TYPES
+            if !check_likes.empty?
+              raise ActiveRecord::InvalidLikeTypes.new(check_likes)
+            end
+          end
+        end
+    end
+  end
+end