activerecord-postgresql-extensions 0.0.10 → 0.0.11

data/lib/postgresql_extensions/postgresql_extensions.rb

@@ -0,0 +1,246 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a new PostgreSQL text search configuration. You must provide
+      # either a parser_name or a source_config option as per the PostgreSQL
+      # text search docs.
+      def create_extension(name, options = {})
+        sql = "CREATE EXTENSION "
+        sql << "IF NOT EXISTS " if options[:if_not_exists]
+        sql << quote_generic(name)
+        sql << " SCHEMA #{quote_generic(options[:schema])}" if options[:schema]
+        sql << " VERSION #{quote_generic(options[:version])}" if options[:version]
+        sql << " FROM #{quote_generic(options[:old_version])}" if options[:old_version]
+
+        execute("#{sql};")
+      end
+
+      # ==== Options
+      #
+      # * <tt>if_exists</tt> - adds IF EXISTS.
+      # * <tt>cascade</tt> - adds CASCADE.
+      def drop_extension(*args)
+        options = args.extract_options!
+
+        sql = 'DROP EXTENSION '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array(args).collect { |name| quote_generic(name) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+
+        execute("#{sql};")
+      end
+
+      def update_extension(name, new_version = nil)
+        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)
+        execute "ALTER EXTENSION #{quote_generic(name)} SET SCHEMA #{quote_schema(schema)};"
+      end
+
+      # Alters an extension. Can be used with an options Hash or in a bloack.
+      # For instance, all of the following examples should produce the
+      # same output.
+      #
+      #   # with options Hash
+      #   alter_extension(:foo, :collation => 'en_CA.UTF-8')
+      #   alter_extension(:foo, :add_collation => 'en_CA.UTF-8')
+      #
+      #   # block mode
+      #   alter_extension(:foo) do |e|
+      #     e.collation 'en_CA.UTF-8'
+      #   end
+      #
+      #   alter_extension(:foo) do |e|
+      #     e.add_collation 'en_CA.UTF-8'
+      #   end
+      #
+      #   # All produce
+      #   #
+      #   # ALTER EXTENSION "foo" ADD COLLATION "en_CA.UTF-8";
+      #
+      # Three versions of each option are available:
+      #
+      # * add_OPTION;
+      # * drop_OPTION; and
+      # * OPTION, which is equiavlent to add_OPTION.
+      #
+      # See the PostgreSQL docs for a list of all of the available extension
+      # options.
+      #
+      # ==== Per-Option, uh... Options
+      #
+      # <tt>:cast</tt>, <tt>:operator</tt>, <tt>:operator_class</tt> and
+      # <tt>:operator_family</tt> can be set their options as a Hash like so:
+      #
+      #   # With the options Hash being the actual values:
+      #   alter_extension(:foo, :cast => { :hello => :world })
+      #
+      #   # With the options Hash containing key-values:
+      #   alter_extension(:foo, :cast => {
+      #     :source => :hello,
+      #     :target => :world
+      #   })
+      #
+      #   # Or with an Array thusly:
+      #   alter_extension(:foo, :cast => [ :source_type, :target_type ])
+      #
+      #   # Or with arguments like this here:
+      #   alter_extension(:foo) do |e|
+      #     e.cast :source_type, :target_type
+      #   end
+      #
+      # The options themselves even have options! It's options all the way
+      # down!
+      #
+      # * <tt>:aggregate</tt> - <tt>:name</tt> and <tt>:types</tt>.
+      #
+      # * <tt>:cast</tt> - <tt>:source</tt> and <tt>:target</tt>.
+      #
+      # * <tt>:function</tt> - <tt>:name</tt> and <tt>:arguments</tt>. The
+      #   <tt>:arguments</tt> option is just a straight up String like in
+      #   the other function manipulation methods.
+      #
+      # * <tt>:operator</tt> - <tt>:name</tt>, <tt>:left_type</tt> and
+      #   <tt>:right_type</tt>.
+      #
+      # * <tt>:operator_class</tt> and <tt>:operator_family</tt> - <tt>:name</tt>
+      #   and <tt>:indexing_method</tt>.
+      def alter_extension(name, options = {})
+        alterer = PostgreSQLExtensionAlterer.new(self, name, options)
+
+        if block_given?
+          yield alterer
+        end
+
+        execute(alterer.to_s) unless alterer.empty?
+      end
+    end
+
+    class PostgreSQLExtensionAlterer
+      def initialize(base, name, options = {}) #:nodoc:
+        @base, @name, @options = base, name, options
+        @sql = options.collect { |k, v| build_statement(k, v) }
+      end
+
+      def empty? #:nodoc:
+        @sql.empty?
+      end
+
+      def to_sql #:nodoc:
+        "#{@sql.join(";\n")};"
+      end
+      alias :to_s :to_sql
+
+      %w{
+        aggregate cast collation conversion domain foreign_data_wrapper
+        foreign_table function operator operator_class operator_family
+        language schema sequence server table
+        text_search_configuration text_search_dictionary text_search_parser text_search_template
+        type view
+      }.each do |f|
+        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+          def add_#{f}(*args)
+            @sql << build_statement(:add_#{f}, *args)
+          end
+          alias :#{f} :add_#{f}
+
+          def drop_#{f}(*args)
+            @sql << build_statement(:drop_#{f}, *args)
+          end
+        EOF
+      end
+
+      private
+        ACTIONS = %w{ add drop }.freeze
+
+        def build_statement(k, *args) #:nodoc:
+          option = k.to_s
+
+          if option =~ /^(add|drop)_/
+            action = $1
+            option = option.gsub(/^(add|drop)_/, '')
+          else
+            action = :add
+          end
+
+          sql = "ALTER EXTENSION #{@base.quote_generic(@name || name)} #{action.to_s.upcase} "
+          sql << case option
+            when 'aggregate'
+              name, types = case v = args[0]
+                when Hash
+                  v.values_at(:name, :types)
+                else
+                  [ args.shift, args ]
+              end
+
+              "AGGREGATE %s (%s)" % [
+                @base.quote_generic(name),
+                Array(types).collect { |t|
+                  @base.quote_generic(t)
+                }.join(', ')
+              ]
+
+            when 'cast'
+              source, target = extract_hash_or_array_options(args, :source, :target)
+
+              "CAST (#{@base.quote_generic(source)} AS #{@base.quote_generic(target)})"
+            when *%w{ collation conversion domain foreign_data_wrapper
+              foreign_table language schema sequence server table
+              text_search_configuration text_search_dictionary text_search_parser
+              text_search_template type view }
+
+              "#{option.upcase.gsub('_', ' ')} #{@base.quote_generic(args[0])}"
+            when 'function'
+              name, arguments = case v = args[0]
+                when Hash
+                  v.values_at(:name, :arguments)
+                else
+                  args.flatten!
+                  [ args.shift, *args ]
+              end
+
+              "FUNCTION #{@base.quote_function(name)}(#{Array(arguments).join(', ')})"
+            when 'operator'
+              name, left_type, right_type =
+                extract_hash_or_array_options(args, :name, :left_type, :right_type)
+
+              "OPERATOR #{@base.quote_generic(name)} (#{@base.quote_generic(left_type)}, #{@base.quote_generic(right_type)})"
+            when 'operator_class', 'operator_family'
+              object_name, indexing_method =
+                extract_hash_or_array_options(args, :name, :indexing_method)
+
+              "#{option.upcase.gsub('_', ' ')} #{@base.quote_generic(object_name)} USING #{@base.quote_generic(indexing_method)})"
+          end
+          sql
+        end
+
+        def assert_valid_action(option) #:nodoc:
+          if !ACTIONS.include? option.to_s.downcase
+            raise ArgumentError.new("Excepted :add or :drop for PostgreSQLExtensionAlterer action.")
+          end unless option.nil?
+        end
+
+        def extract_hash_or_array_options(hash_or_array, *keys) #:nodoc:
+          case v = hash_or_array[0]
+            when Hash
+              if (keys - (sliced = v.slice(*keys)).keys).length == 0
+                keys.collect do |k|
+                  sliced[k]
+                end
+              else
+                [ v.keys.first, v.values.first ]
+              end
+            else
+              v = hash_or_array.flatten
+              [ v.shift, *v ]
+          end
+        end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_functions.rb

@@ -91,20 +91,19 @@ module ActiveRecord
       #
       # ==== Example
       #
-      #  ### ruby
-      #  create_function('tester_function', 'integer',
-      #    'integer', 'sql', :behavior => :immutable, :set => { :search_path => :from_current }, :force => true) do
-      #    "select $1;"
-      #  end
+      #   create_function('tester_function', 'integer',
+      #     'integer', 'sql', :behavior => :immutable, :set => { :search_path => :from_current }, :force => true) do
+      #     "select $1;"
+      #   end
       #
-      #  # Produces
-      #  #
-      #  # CREATE OR REPLACE FUNCTION "tester_function"(integer) RETURNS integer AS $$
-      #  #   select $1;
-      #  # $$
-      #  # LANGUAGE "sql"
-      #  #   IMMUTABLE
-      #  #   SET "search_path" FROM CURRENT;
+      #   # Produces:
+      #   #
+      #   # CREATE OR REPLACE FUNCTION "tester_function"(integer) RETURNS integer AS $$
+      #   #   select $1;
+      #   # $$
+      #   # LANGUAGE "sql"
+      #   #   IMMUTABLE
+      #   #   SET "search_path" FROM CURRENT;
       def create_function(name, args, returns, language, options = {})
         body = yield.to_s
         execute PostgreSQLFunctionDefinition.new(self, name, args, returns, language, body, options).to_s
@@ -122,7 +121,7 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << "#{quote_function(name)}(#{args})"
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        execute "#{sql};"
       end
 
       # Renames a function.
@@ -155,29 +154,28 @@ module ActiveRecord
       #
       # Both of the following examples should produce the same output.
       #
-      #  ### ruby
-      #  # with options Hash
-      #  alter_function('my_function', 'integer', :rename_to => 'another_function')
-      #  alter_function('another_function', 'integer', :owner_to => 'jdoe')
+      #   # with options Hash
+      #   alter_function('my_function', 'integer', :rename_to => 'another_function')
+      #   alter_function('another_function', 'integer', :owner_to => 'jdoe')
       #
-      #  # block mode
-      #  alter_function('my_function', 'integer') do |f|
-      #    f.rename_to 'another_function'
-      #    f.owner_to 'jdoe'
-      #  end
+      #   # block mode
+      #   alter_function('my_function', 'integer') do |f|
+      #     f.rename_to 'another_function'
+      #     f.owner_to 'jdoe'
+      #   end
       #
-      #  # Produces
-      #  #
-      #  # ALTER FUNCTION "my_function"(integer) OWNER TO "jdoe";
-      #  # ALTER FUNCTION "my_function"(integer) RENAME TO "another_function";
+      #   # Produces:
+      #   #
+      #   # ALTER FUNCTION "my_function"(integer) OWNER TO "jdoe";
+      #   # ALTER FUNCTION "my_function"(integer) RENAME TO "another_function";
       def alter_function(name, args, options = {})
+        alterer = PostgreSQLFunctionAlterer.new(self, name, args, options)
+
         if block_given?
-          alterer = PostgreSQLFunctionAlterer.new(self, name, args)
           yield alterer
-          execute alterer.to_s unless alterer.empty?
-        else
-          execute PostgreSQLFunctionAlterer.new(self, name, args, options).to_s
         end
+
+        execute alterer.to_s unless alterer.empty?
       end
     end
 
@@ -271,7 +269,7 @@ module ActiveRecord
         sql << "    COST #{options[:cost].to_i}\n" if options[:cost]
         sql << "    ROWS #{options[:rows].to_i}\n" if options[:rows]
         sql << "    " << (set_options(options[:set]) * "\n    ") if options[:set]
-        sql.strip
+        "#{sql.strip};"
       end
       alias :to_s :to_sql
     end
@@ -291,7 +289,7 @@ module ActiveRecord
       end
 
       def to_sql #:nodoc:
-        @sql.join(";\n")
+        "#{@sql.join(";\n")};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_geometry.rb

@@ -127,14 +127,14 @@ module ActiveRecord
             "DELETE FROM \"geometry_columns\" WHERE f_table_catalog = '' AND " +
             "f_table_schema = %s AND " +
             "f_table_name = %s AND " +
-            "f_geometry_column = %s",
+            "f_geometry_column = %s;",
             base.quote(current_schema.to_s),
             base.quote(current_table_name.to_s),
             base.quote(column_name.to_s)
           )
 
           @post_processing << sprintf(
-            "INSERT INTO \"geometry_columns\" VALUES ('', %s, %s, %s, %d, %d, %s)",
+            "INSERT INTO \"geometry_columns\" VALUES ('', %s, %s, %s, %d, %d, %s);",
             base.quote(current_schema.to_s),
             base.quote(current_table_name.to_s),
             base.quote(column_name.to_s),

data/lib/postgresql_extensions/postgresql_indexes.rb

@@ -93,18 +93,17 @@ module ActiveRecord
       #
       # ==== Examples
       #
-      #  ### ruby
-      #  # using multiple columns
-      #  create_index('this_is_my_index', :foo, [ :id, :ref_id ], :using => :gin)
-      #  # => CREATE INDEX "this_is_my_index" ON "foo"("id", "ref_id");
+      #   # using multiple columns
+      #   create_index('this_is_my_index', :foo, [ :id, :ref_id ], :using => :gin)
+      #   # => CREATE INDEX "this_is_my_index" ON "foo"("id", "ref_id");
       #
-      #  # using expressions
-      #  create_index('this_is_another_idx', :foo, { :expression => 'COALESCE(ref_id, 0)' })
-      #  # => CREATE INDEX "this_is_another_idx" ON "foo"((COALESCE(ref_id, 0)));
+      #   # using expressions
+      #   create_index('this_is_another_idx', :foo, { :expression => 'COALESCE(ref_id, 0)' })
+      #   # => CREATE INDEX "this_is_another_idx" ON "foo"((COALESCE(ref_id, 0)));
       #
-      #  # additional options
-      #  create_index('search_idx', :foo, :tsvector, :using => :gin)
-      #  # => CREATE INDEX "search_idx" ON "foo" USING "gin"("tsvector");
+      #   # additional options
+      #   create_index('search_idx', :foo, :tsvector, :using => :gin)
+      #   # => CREATE INDEX "search_idx" ON "foo" USING "gin"("tsvector");
       def create_index(name, table, columns, options = {})
         execute PostgreSQLIndexDefinition.new(self, name, table, columns, options).to_s
       end
@@ -125,17 +124,17 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(name).collect { |i| quote_generic(i) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        execute("#{sql};")
       end
 
       # Renames an index.
       def rename_index(name, new_name, options = {})
-        execute "ALTER INDEX #{quote_generic(name)} RENAME TO #{quote_generic(new_name)}"
+        execute "ALTER INDEX #{quote_generic(name)} RENAME TO #{quote_generic(new_name)};"
       end
 
       # Changes an index's tablespace.
       def alter_index_tablespace(name, tablespace, options = {})
-        execute "ALTER INDEX #{quote_generic(name)} SET TABLESPACE #{quote_tablespace(tablespace)}"
+        execute "ALTER INDEX #{quote_generic(name)} SET TABLESPACE #{quote_tablespace(tablespace)};"
       end
     end
 
@@ -181,7 +180,7 @@ module ActiveRecord
         sql << " WITH (FILLFACTOR = #{options[:fill_factor].to_i})" if options[:fill_factor]
         sql << " TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
         sql << " WHERE #{options[:conditions] || options[:where]}" if options[:conditions] || options[:where]
-        sql
+        "#{sql};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_languages.rb

@@ -37,7 +37,7 @@ module ActiveRecord
         sql << "PROCEDURAL LANGUAGE #{quote_language(language)}"
         sql << " HANDLER #{quote_language(options[:call_handler])}" if options[:call_handler]
         sql << " VALIDATOR #{options[:validator]}" if options[:validator]
-        execute sql
+        execute("#{sql};")
       end
 
       # Drops a language.
@@ -51,17 +51,17 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << quote_language(language)
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        execute("#{sql};")
       end
 
       # Renames a language.
       def alter_language_name old_language, new_language, options = {}
-        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(old_language)} RENAME TO #{quote_language(new_language)}"
+        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(old_language)} RENAME TO #{quote_language(new_language)};"
       end
 
       # Changes a language's owner.
       def alter_language_owner language, role, options = {}
-        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(language)} OWNER TO #{quote_language(role)}"
+        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(language)} OWNER TO #{quote_language(role)};"
       end
 
       # Returns an Array of available languages.