activerecord-postgresql-extensions 0.0.7

data/lib/postgresql_extensions/postgresql_triggers.rb

@@ -0,0 +1,131 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  class InvalidTriggerCallType < ActiveRecordError #:nodoc:
+    def initialize(called)
+      super("Invalid trigger call type - #{called}")
+    end
+  end
+
+  class InvalidTriggerEvents < ActiveRecordError #:nodoc:
+    def initialize(events)
+      super("Invalid trigger event(s) - #{events.inspect}")
+    end
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a PostgreSQL trigger.
+      #
+      # The +called+ argument specifies when the trigger is called and
+      # can be either <tt>:before</tt> or <tt>:after</tt>.
+      #
+      # +events+ can be on or more of <tt>:insert</tt>,
+      # <tt>:update</tt> or <tt>:delete</tt>. There are no
+      # <tt>:select</tt> triggers, as SELECT generally doesn't modify
+      # the database.
+      #
+      # +table+ is obviously the table the trigger will be created on
+      # while +function+ is the name of the procedure to call when the
+      # trigger is fired.
+      #
+      # ==== Options
+      #
+      # * <tt>:for_each</tt> - defines whether the trigger will be fired
+      #   on each row in a statement or on the statement itself. Possible
+      #   values are <tt>:row</tt> and <tt>:statement</tt>, with
+      #   <tt>:statement</tt> being the default.
+      # * <tt>:args</tt> - if the trigger function requires any
+      #   arguments then this is the place to let everyone know about it.
+      #
+      # ==== Example
+      #
+      #  ### ruby
+      #  create_trigger(
+      #    'willie_nelsons_trigger',
+      #    :before,
+      #    :update,
+      #    { :nylon => :guitar },
+      #    'strum_trigger',
+      #    :for_each => :row
+      #  )
+      #  # => CREATE TRIGGER "willie_nelsons_trigger" BEFORE UPDATE
+      #  #    ON "nylon"."guitar" FOR EACH ROW EXECUTE PROCEDURE "test_trigger"();
+      def create_trigger(name, called, events, table, function, options = {})
+        execute PostgreSQLTriggerDefinition.new(self, name, called, events, table, function, options).to_s
+      end
+
+      # Drops a trigger.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - cascades changes down to objects referring
+      #   to the trigger.
+      def drop_trigger(name, table, options = {})
+        sql = 'DROP TRIGGER '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << "#{quote_generic(name)} ON #{quote_table_name(table)}"
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      # Renames a trigger.
+      def rename_trigger(name, table, new_name, options = {})
+        execute "ALTER TRIGGER #{quote_generic(name)} ON #{quote_table_name(table)} RENAME TO #{quote_generic(new_name)}"
+      end
+    end
+
+    # Creates a PostgreSQL trigger definition. This class isn't really
+    # meant to be used directly. You'd be better off sticking to
+    # PostgreSQLAdapter#create_trigger. Honestly.
+    class PostgreSQLTriggerDefinition
+      attr_accessor :base, :name, :called, :events, :table, :function, :options
+
+      def initialize(base, name, called, events, table, function, options = {}) #:nodoc:
+        assert_valid_called(called)
+        assert_valid_events(events)
+        assert_valid_for_each(options[:for_each])
+
+        @base, @name, @events, @called, @table, @function, @options =
+          base, name, events, called, table, function, options
+      end
+
+      def to_sql #:nodoc:
+        sql = "CREATE TRIGGER #{base.quote_generic(name)} #{called.to_s.upcase} "
+        sql << Array(events).collect { |e| e.to_s.upcase }.join(' OR ')
+        sql << " OF " << Array(options[:of]).collect { |o| base.quote_generic(o) }.join(', ') if options[:of].present?
+        sql << " ON #{base.quote_table_name(table)}"
+        sql << " FOR EACH #{options[:for_each].to_s.upcase}" if options[:for_each]
+        sql << " EXECUTE PROCEDURE #{base.quote_function(function)}(#{options[:args]})"
+        sql
+      end
+      alias :to_s :to_sql
+
+      private
+        CALLED_TYPES = %w{ before after }.freeze
+        EVENT_TYPES = %w{ insert update delete }.freeze
+        FOR_EACH_TYPES = %w{ row statement }.freeze
+
+        def assert_valid_called(c) #:nodoc:
+          if !CALLED_TYPES.include?(c.to_s.downcase)
+            raise ActiveRecord::InvalidTriggerCallType.new(c)
+          end
+        end
+
+        def assert_valid_events(events) #:nodoc:
+          check_events = Array(events).collect(&:to_s) - EVENT_TYPES
+          if !check_events.empty?
+            raise ActiveRecord::InvalidTriggerEvent.new(check_events)
+          end
+        end
+
+        def assert_valid_for_each(f) #:nodoc:
+          if !FOR_EACH_TYPES.include?(f.to_s.downcase)
+            raise ActiveRecord::InvalidTriggerForEach.new(f)
+          end unless f.nil?
+        end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_types.rb

@@ -0,0 +1,17 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Returns an Array of available languages.
+      def types(name = nil)
+        query(%{SELECT typname FROM pg_type}, name).map { |row| row[0] }
+      end
+
+      def type_exists?(name)
+        types.include?(name.to_s)
+      end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_views.rb

@@ -0,0 +1,103 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a new PostgreSQL view.
+      #
+      # +name+ is the name of the view. View quoting works the same as
+      # table quoting, so you can use PostgreSQLAdapter#with_schema and
+      # friends. See PostgreSQLAdapter#with_schema and
+      # PostgreSQLAdapter#quote_table_name for details.
+      #
+      # +query+ is the SELECT query to use for the view. This is just
+      # a straight-up String, so quoting rules will not apply.
+      #
+      # Note that you can grant privileges on views using the
+      # grant_view_privileges method and revoke them using
+      # revoke_view_privileges.
+      #
+      # ==== Options
+      #
+      # * <tt>:replace</tt> - adds a REPLACE clause, as in "CREATE OR
+      #   REPLACE".
+      # * <tt>:temporary</tt> - adds a TEMPORARY clause.
+      # * <tt>:columns</tt> - you can rename the output columns as
+      #   necessary. Note that this can be an Array and that it must be
+      #   the same length as the number of output columns created by
+      #   +query+.
+      #
+      # ==== Examples
+      #
+      #  ### ruby
+      #  create_view(:foo_view, 'SELECT * FROM bar')
+      #  # => CREATE VIEW "foo_view" AS SELECT * FROM bar;
+      #
+      #  create_view(
+      #    { :geospatial => :foo_view },
+      #    'SELECT * FROM bar',
+      #    :columns => [ :id, :name, :the_geom ]
+      #  )
+      #  # => CREATE VIEW "geospatial"."foo_view" ("id", "name", "the_geom") AS SELECT * FROM bar;
+      def create_view(name, query, options = {})
+        execute PostgreSQLViewDefinition.new(self, name, query, options).to_s
+      end
+
+      # Drops a view.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_view(name, options = {})
+        sql = 'DROP VIEW '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array(name).collect { |v| quote_view_name(v) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      # Renames a view.
+      def rename_view(name, new_name, options = {})
+        execute "ALTER TABLE #{quote_view_name(name)} RENAME TO #{quote_generic_ignore_schema(new_name)}"
+      end
+
+      # Change the ownership of a view.
+      def alter_view_owner(name, role, options = {})
+        execute "ALTER TABLE #{quote_view_name(name)} OWNER TO #{quote_role(role)}"
+      end
+
+      # Alter a view's schema.
+      def alter_view_schema(name, schema, options = {})
+        execute "ALTER TABLE #{quote_view_name(name)} SET SCHEMA #{quote_schema(schema)}"
+      end
+    end
+
+    # Creates a PostgreSQL view definition. This class isn't really meant
+    # to be used directly. Instead, see PostgreSQLAdapter#create_view
+    # for usage.
+    class PostgreSQLViewDefinition
+      attr_accessor :base, :name, :query, :options
+
+      def initialize(base, name, query, options = {}) #:nodoc:
+        @base, @name, @query, @options = base, name, query, options
+      end
+
+      def to_sql #:nodoc:
+        sql = 'CREATE '
+        sql << 'OR REPLACE ' if options[:replace]
+        sql << 'TEMPORARY ' if options[:temporary]
+        sql << "VIEW #{base.quote_view_name(name)} "
+        if options[:columns]
+          sql << '(' << Array(options[:columns]).collect do |c|
+            base.quote_column_name(c)
+          end.join(', ') << ') '
+        end
+        sql << "AS #{query}"
+        sql
+      end
+      alias :to_s :to_sql
+    end
+  end
+end

data/postgresql-extensions.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{postgresql-extensions}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["J Smith"]
+  s.date = %q{2010-11-30}
+  s.description = %q{A whole bunch of extensions the Rails PostgreSQL adapter.}
+  s.email = %q{code@zoocasa.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+    "Rakefile",
+    "lib/postgresql_adapter_extensions.rb",
+    "lib/postgresql_constraints.rb",
+    "lib/postgresql_functions.rb",
+    "lib/postgresql_geometry.rb",
+    "lib/postgresql_indexes.rb",
+    "lib/postgresql_languages.rb",
+    "lib/postgresql_permissions.rb",
+    "lib/postgresql_rules.rb",
+    "lib/postgresql_schemas.rb",
+    "lib/postgresql_sequences.rb",
+    "lib/postgresql_tables.rb",
+    "lib/postgresql_triggers.rb",
+    "lib/postgresql_views.rb"
+  ]
+  s.homepage = %q{http://github.com/zoocasa/postgresql-extensions}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A whole bunch of extensions the Rails PostgreSQL adapter.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/adapter_test.rb

@@ -0,0 +1,45 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class AdapterExtensionTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_quote_table_name_with_schema_string
+    assert_equal(%{"foo"."bar"}, ARBC.quote_table_name('foo.bar'))
+  end
+
+  def test_quote_table_name_with_schema_hash
+    assert_equal(%{"foo"."bar"}, ARBC.quote_table_name(:foo => :bar))
+  end
+
+  def test_quote_table_name_with_current_schema
+    assert_equal(%{"foo"."bar"}, ARBC.with_schema(:foo) {
+      ARBC.quote_table_name(:bar)
+    })
+  end
+
+  def test_quote_table_name_with_current_schema_ignored
+    assert_equal(%{"bar"}, ARBC.with_schema(:foo) {
+      ARBC.ignore_schema {
+        ARBC.quote_table_name(:bar)
+      }
+    })
+  end
+
+  def test_quote_schema
+    assert_equal('PUBLIC', ARBC.quote_schema(:public))
+    assert_equal(%{"foo"}, ARBC.quote_schema(:foo))
+  end
+
+  def test_other_quoting
+    assert_equal(%{"foo"}, ARBC.quote_generic(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_role(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_rule(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_language(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_sequence(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_function(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_view_name(:foo))
+    assert_equal(%{"foo"}, ARBC.quote_tablespace(:foo))
+  end
+end

data/test/constraints_test.rb

@@ -0,0 +1,98 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class ConstraintTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def setup
+    clear_statements!
+  end
+
+  def test_create_table_with_unique_constraint_on_table
+    Mig.create_table(:foo) do |t|
+      t.integer :bar_id
+      t.text :name
+      t.text :email
+      t.unique_constraint [ :id, :bar_id ]
+      t.unique_constraint [ :name, :email ], :tablespace => 'fubar'
+    end
+
+    assert_equal((<<-EOF).strip, statements[0])
+CREATE TABLE "foo" (
+  "id" serial primary key,
+  "bar_id" integer,
+  "name" text,
+  "email" text,
+  UNIQUE ("id", "bar_id"),
+  UNIQUE ("name", "email") USING INDEX TABLESPACE "fubar"
+)
+EOF
+  end
+
+  def test_create_table_with_unique_constraint_on_column
+    Mig.create_table(:foo) do |t|
+      t.integer :bar_id, :unique => true
+    end
+
+    assert_equal((<<-EOF).strip, statements[0])
+CREATE TABLE "foo" (
+  "id" serial primary key,
+  "bar_id" integer,
+  UNIQUE ("bar_id")
+)
+EOF
+  end
+
+  def test_add_unique_constraint
+    Mig.add_unique_constraint(:foo, :bar_id)
+    Mig.add_unique_constraint(
+      :foo,
+      :bar_id,
+      :tablespace => 'fubar',
+      :storage_parameters => 'FILLFACTOR=10',
+      :name => 'bar_id_unique'
+    )
+
+    assert_equal([
+      "ALTER TABLE \"foo\" ADD UNIQUE (\"bar_id\")",
+      "ALTER TABLE \"foo\" ADD CONSTRAINT \"bar_id_unique\" UNIQUE (\"bar_id\") WITH (FILLFACTOR=10) USING INDEX TABLESPACE \"fubar\""
+    ], statements)
+  end
+
+  def test_add_foreign_key
+    Mig.add_foreign_key(:foo, :bar_id, :bar)
+    Mig.add_foreign_key(:foo, :bar_id, :bar, :ogc_fid, :name => 'bar_fk')
+    Mig.add_foreign_key(:foo, [ :one_id, :bar_id ], :bar, [ :one_id, :bar_id ], :match => 'full')
+    Mig.add_foreign_key(:foo, :bar_id, :bar, :on_delete => :cascade, :on_delete => :set_default)
+    Mig.add_foreign_key(:foo, :bar_id, :bar, :deferrable => :immediate)
+
+    assert_equal([
+      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\"",
+      "ALTER TABLE \"foo\" ADD CONSTRAINT \"bar_fk\" FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" (\"ogc_fid\")",
+      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"one_id\", \"bar_id\") REFERENCES \"bar\" (\"one_id\", \"bar_id\") MATCH FULL",
+      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" ON DELETE SET DEFAULT",
+      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" DEFERRABLE INITIALLY IMMEDIATE"
+    ], statements)
+  end
+
+  def test_drop_constraint
+    Mig.drop_constraint(:foo, :bar)
+    Mig.drop_constraint(:foo, :bar, :cascade => true)
+
+    assert_equal([
+      "ALTER TABLE \"foo\" DROP CONSTRAINT \"bar\"",
+      "ALTER TABLE \"foo\" DROP CONSTRAINT \"bar\" CASCADE"
+    ], statements)
+  end
+
+  def test_add_check_constraint
+    Mig.add_check_constraint(:foo, 'length(name) < 100')
+    Mig.add_check_constraint(:foo, 'length(name) < 100', :name => 'name_length_check')
+
+    assert_equal([
+      "ALTER TABLE \"foo\" ADD CHECK (length(name) < 100)",
+      "ALTER TABLE \"foo\" ADD CONSTRAINT \"name_length_check\" CHECK (length(name) < 100)"
+    ], statements)
+  end
+end