activerecord-postgresql-extensions 0.0.10 → 0.0.11

data/lib/postgresql_extensions/postgresql_permissions.rb

@@ -80,7 +80,7 @@ module ActiveRecord
         sql << ' TO '
         sql << Array(role_names).collect { |r| quote_role(r) }.join(', ')
         sql << ' WITH ADMIN OPTION' if options[:with_admin_option]
-        execute sql
+        execute("#{sql};")
       end
 
       # Revokes table privileges. You can specify multiple tables,
@@ -155,7 +155,7 @@ module ActiveRecord
         sql << ' FROM '
         sql << Array(role_names).collect { |r| quote_role(r) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        execute("#{sql};")
       end
     end
 
@@ -204,12 +204,11 @@ module ActiveRecord
     #
     # ==== Examples
     #
-    #  ### ruby
-    #  grant_table_privileges([ :table1, :table2 ], :select, :joe)
-    #  # => GRANT SELECT ON TABLE "table1", "table2" TO "joe"
+    #   grant_table_privileges([ :table1, :table2 ], :select, :joe)
+    #   # => GRANT SELECT ON TABLE "table1", "table2" TO "joe"
     #
-    #  grant_sequence_privileges(:my_seq, [ :select, :update ], :public)
-    #  # => GRANT SELECT, UPDATE ON SEQUENCE "my_seq" TO PUBLIC
+    #   grant_sequence_privileges(:my_seq, [ :select, :update ], :public)
+    #   # => GRANT SELECT, UPDATE ON SEQUENCE "my_seq" TO PUBLIC
     #
     # You can specify the <tt>:with_grant_option</tt> in any of the
     # grant_*_privilege methods to add a WITH GRANT OPTION clause to
@@ -244,7 +243,7 @@ module ActiveRecord
         end.join(', ')
 
         sql << ' WITH GRANT OPTION' if options[:with_grant_option]
-        sql
+        "#{sql};"
       end
       alias :to_s :to_sql
     end
@@ -264,12 +263,11 @@ module ActiveRecord
     #
     # ==== Examples
     #
-    #  ### ruby
-    #  revoke_table_privileges([ :table1, :table2 ], :select, :joe)
-    #  # => REVOKE SELECT ON TABLE "table1", "table2" FROM "joe"
+    #   revoke_table_privileges([ :table1, :table2 ], :select, :joe)
+    #   # => REVOKE SELECT ON TABLE "table1", "table2" FROM "joe"
     #
-    #  revoke_sequence_privileges(:my_seq, [ :select, :update ], :public)
-    #  # => REVOKE SELECT, UPDATE ON SEQUENCE "my_seq" FROM PUBLIC
+    #   revoke_sequence_privileges(:my_seq, [ :select, :update ], :public)
+    #   # => REVOKE SELECT, UPDATE ON SEQUENCE "my_seq" FROM PUBLIC
     #
     # You can specify the <tt>:grant_option_for</tt> in any of the
     # revoke_*_privilege methods to add a GRANT OPTION FOR clause to
@@ -314,7 +312,7 @@ module ActiveRecord
         end.join(', ')
 
         sql << ' CASCADE' if options[:cascade]
-        sql
+        "#{sql};"
       end
       alias :to_s :to_sql
     end

data/lib/postgresql_extensions/postgresql_roles.rb

@@ -24,7 +24,7 @@ module ActiveRecord
         sql = 'DROP ROLE '
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(name).collect { |r| quote_role(r) }.join(', ')
-        execute sql
+        execute("#{sql};")
       end
       alias :drop_user :drop_role
     end
@@ -112,7 +112,7 @@ module ActiveRecord
           sql << Array(options[:admin]).collect { |r| base.quote_role(r) }.join(', ')
         end
 
-        sql.join(' ')
+        "#{sql.join(' ')};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_rules.rb

@@ -37,22 +37,21 @@ module ActiveRecord
       #
       # ==== 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;
+      #   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)}"
+        execute "DROP RULE #{quote_rule(name)} ON #{quote_table_name(table)};"
       end
     end
 
@@ -89,6 +88,8 @@ module ActiveRecord
         else
           commands.to_s
         end
+
+        "#{sql};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_schemas.rb

@@ -18,7 +18,7 @@ module ActiveRecord
       def create_schema schema, options = {}
         sql = "CREATE SCHEMA #{quote_schema(schema)}"
         sql << " AUTHORIZATION #{quote_role(options[:authorization])}" if options[:authorization]
-        execute sql
+        execute("#{sql};")
       end
 
       # Drops a schema.
@@ -32,17 +32,17 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(schemas).collect { |s| quote_schema(s) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        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)}"
+        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)}"
+        execute "ALTER SCHEMA #{quote_schema(schema)} OWNER TO #{quote_role(role)};"
       end
     end
   end

data/lib/postgresql_extensions/postgresql_sequences.rb

@@ -42,17 +42,16 @@ module ActiveRecord
       #
       # ==== 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";
+      #   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
@@ -69,17 +68,17 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(name).collect { |s| quote_sequence(s) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        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)}"
+        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)}"
+        execute "ALTER SEQUENCE #{quote_sequence(name)} SET SCHEMA #{quote_schema(schema)};"
       end
 
       # Alters any of the various options for a sequence. See
@@ -112,7 +111,7 @@ module ActiveRecord
           else
             'false'
           end <<
-          ')'
+          ');'
       end
 
       # Returns an Array of available sequences.
@@ -193,7 +192,7 @@ module ActiveRecord
         if action != :create && options.has_key?(:restart_with)
           sql << "RESTART WITH #{options[:restart_with].to_i}"
         end
-        sql.join(' ')
+        "#{sql.join(' ')};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_tables.rb

@@ -13,7 +13,7 @@ module ActiveRecord
     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)}"
+        execute "ALTER TABLE #{quote_schema(table_name)} SET SCHEMA #{quote_schema(schema)};"
       end
 
       alias :original_create_table :create_table
@@ -69,24 +69,23 @@ module ActiveRecord
       #
       # ==== 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
+      #   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");
+      #   # 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.
       #
@@ -131,7 +130,7 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(tables).collect { |t| quote_table_name(t) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        execute("#{sql};")
       end
 
       alias :original_rename_table :rename_table
@@ -140,7 +139,7 @@ module ActiveRecord
       # 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)}"
+        execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_generic_ignore_schema(new_name)};"
       end
 
       private
@@ -195,7 +194,7 @@ module ActiveRecord
         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
+        "#{sql};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_text_search.rb

@@ -0,0 +1,313 @@
+
+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_text_search_configuration(name, options = {})
+        if options[:parser_name] && options[:source_config]
+          raise ArgumentError.new("You can't define both :parser_name and :source_config options.")
+        elsif options[:parser_name].blank? && options[:source_config].blank?
+          raise ArgumentError.new("You must provide either a :parser_name or a :source_config.")
+        end
+
+        sql = "CREATE TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} ("
+
+        ignore_schema do
+          sql << if options[:parser_name]
+            "PARSER = #{quote_generic_with_schema(options[:parser_name])}"
+          else
+            "COPY = #{quote_generic_with_schema(options[:source_config])}"
+          end
+        end
+
+        sql << ")"
+        execute("#{sql};")
+      end
+
+      def add_text_search_configuration_mapping(name, tokens, dictionaries)
+        add_or_alter_text_search_configuration_mapping(name, tokens, dictionaries, :action => :add)
+      end
+
+      def alter_text_search_configuration_mapping(name, tokens, dictionaries)
+        add_or_alter_text_search_configuration_mapping(name, tokens, dictionaries, :action => :alter)
+      end
+
+      # This method is semi-private and should only really be used via
+      # add_text_search_configuration_mapping and alter_text_search_configuration_mapping.
+      #
+      # ==== Options
+      #
+      # * <tt>:action</tt> - either :add or :alter.
+      def add_or_alter_text_search_configuration_mapping(name, tokens, dictionaries, options = {})
+        options = {
+          :action => :add
+        }.merge(options)
+
+        if ![ :add, :alter ].include?(options[:action])
+          raise ArgumentError.new(":action option must be eithe :add or :alter.")
+        end
+
+        add_or_alter = options[:action].to_s.upcase
+
+        sql = "ALTER TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} #{add_or_alter} MAPPING FOR "
+        sql << Array(tokens).collect { |token|
+          quote_generic(token)
+        }.join(', ')
+
+        sql << ' WITH '
+
+        sql << Array(dictionaries).collect { |dictionary|
+          quote_generic(dictionary)
+        }.join(', ')
+
+        execute("#{sql};")
+      end
+
+      def replace_text_search_configuration_dictionary(name, old_dictionary, new_dictionary)
+        sql = "ALTER TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} ALTER MAPPING REPLACE "
+        sql << "#{quote_generic(old_dictionary)} WITH #{quote_generic(new_dictionary)}"
+
+        execute("#{sql};")
+      end
+
+      def alter_text_search_configuration_mapping_replace_dictionary(name, mappings, old_dictionary, new_dictionary)
+        if mappings.blank?
+          raise ArgumentError.new("Expected one or more mappings to alter.")
+        end
+
+        sql = "ALTER TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} ALTER MAPPING FOR "
+        sql << Array(mappings).collect { |token_type|
+          quote_generic(token_type)
+        }.join(', ')
+        sql << " REPLACE #{quote_generic(old_dictionary)} WITH #{quote_generic(new_dictionary)}"
+
+        execute("#{sql};")
+      end
+
+      def drop_text_search_configuration_mapping(name, *args)
+        options = args.extract_options!
+        mappings = args
+
+        if mappings.blank?
+          raise ArgumentError.new("Expected one or more mappings to drop.")
+        end
+
+        sql = "ALTER TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} DROP MAPPING "
+
+        if options[:if_exists]
+          sql << 'IF EXISTS '
+        end
+
+        sql << 'FOR '
+        sql << mappings.collect { |token_type|
+          quote_generic(token_type)
+        }.join(', ')
+
+        execute("#{sql};")
+      end
+
+       def rename_text_search_configuration(old_name, new_name)
+        execute("ALTER TEXT SEARCH CONFIGURATION %s RENAME TO %s;" % [
+          quote_generic_with_schema(old_name),
+          quote_generic_with_schema(new_name)
+        ])
+      end
+
+      def alter_text_search_configuration_owner(name, role)
+        execute "ALTER TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} OWNER TO #{quote_role(role)};"
+      end
+
+      def alter_text_search_configuration_schema(name, schema)
+        execute "ALTER TEXT SEARCH CONFIGURATION #{quote_generic_with_schema(name)} SET SCHEMA #{quote_schema(schema)};"
+      end
+
+      # Drops a text search configuration.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_text_search_configuration(name, options = {})
+        sql = 'DROP TEXT SEARCH CONFIGURATION '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_generic_with_schema(name)
+        sql << ' CASCADE' if options[:cascade]
+
+        execute("#{sql};")
+      end
+
+      def create_text_search_dictionary(name, template, options = {})
+        sql = "CREATE TEXT SEARCH DICTIONARY #{quote_generic_with_schema(name)} ("
+        sql << "TEMPLATE = #{quote_generic_with_schema(template)}"
+
+        if !options.blank?
+          sql << ', '
+          sql << options.collect { |k, v|
+            "#{quote_generic(k)} = #{quote(v)}"
+          }.join(', ')
+        end
+
+        sql << ')'
+
+        execute("#{sql};")
+      end
+
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_text_search_dictionary(name, options = {})
+        sql = 'DROP TEXT SEARCH DICTIONARY '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_generic_with_schema(name)
+        sql << ' CASCADE' if options[:cascade]
+
+        execute("#{sql};")
+      end
+
+      def alter_text_search_dictionary(name, options)
+        if options.blank?
+          raise ArgumentError.new("Expected some options to alter.")
+        end
+
+        sql = "ALTER TEXT SEARCH DICTIONARY #{quote_generic_with_schema} ("
+        sql << options.collect { |k, v|
+          "#{quote_generic(k)} = #{quote(v)}"
+        }.join(', ')
+        sql << ')'
+
+        execute("#{sql};")
+      end
+
+      def rename_text_search_dictionary(old_name, new_name)
+        execute("ALTER TEXT SEARCH DICTIONARY %s RENAME TO %s;" % [
+          quote_generic_with_schema(old_name),
+          quote_generic_with_schema(new_name)
+        ])
+      end
+
+      def alter_text_search_dictionary_owner(name, role)
+        execute "ALTER TEXT SEARCH DICTIONARY #{quote_generic_with_schema(name)} OWNER TO #{quote_role(role)};"
+      end
+
+      def alter_text_search_dictionary_schema(name, schema)
+        execute "ALTER TEXT SEARCH DICTIONARY #{quote_generic_with_schema(name)} SET SCHEMA #{quote_schema(schema)};"
+      end
+
+
+      # ==== Options
+      #
+      # :lexize - the function used by the template lexer. Required.
+      # :init - the initialization function for the template. Optional.
+      def create_text_search_template(name, options = {})
+        if options[:lexize].blank?
+          raise ArgumentError.new("Expected to see a :lexize option.")
+        end
+
+        sql = "CREATE TEXT SEARCH TEMPLATE #{quote_generic_with_schema(name)} ("
+
+        if options[:init]
+          sql << "INIT = #{quote_function(options[:init])}, "
+        end
+
+        sql << "LEXIZE = #{quote_function(options[:lexize])}"
+        sql << ')'
+
+        execute("#{sql};")
+      end
+
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_text_search_template(name, options = {})
+        sql = 'DROP TEXT SEARCH TEMPLATE '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_generic_with_schema(name)
+        sql << ' CASCADE' if options[:cascade]
+
+        execute("#{sql};")
+      end
+
+      def rename_text_search_template(old_name, new_name)
+        execute("ALTER TEXT SEARCH TEMPLATE %s RENAME TO %s;" % [
+          quote_generic_with_schema(old_name),
+          quote_generic_with_schema(new_name)
+        ])
+      end
+
+      def alter_text_search_template_schema(name, schema)
+        execute "ALTER TEXT SEARCH TEMPLATE #{quote_generic_with_schema(name)} SET SCHEMA #{quote_schema(schema)};"
+      end
+
+
+
+      # The :start, :gettoken, :end and :lextypes options are required as per
+      # the PostgreSQL docs, while the :headline option is optional.
+      def create_text_search_parser(name, options = {})
+        if (missing_options = [ :start, :gettoken, :end, :lextypes ] - options.keys).present?
+          raise ArgumentError.new("Missing options: #{missing_options}.")
+        end
+
+        sql = "CREATE TEXT SEARCH PARSER #{quote_generic_with_schema(name)} ("
+        sql << "START = #{quote_function(options[:start])}, "
+        sql << "GETTOKEN = #{quote_function(options[:gettoken])}, "
+        sql << "END = #{quote_function(options[:end])}, "
+        sql << "LEXTYPES = #{quote_function(options[:lextypes])}"
+
+        if options[:headline]
+          sql << ", HEADLINE = #{quote_function(options[:headline])}"
+        end
+
+        sql << ')'
+
+        execute("#{sql};")
+      end
+
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_text_search_parser(name, options = {})
+        sql = 'DROP TEXT SEARCH PARSER '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_generic_with_schema(name)
+        sql << ' CASCADE' if options[:cascade]
+
+        execute("#{sql};")
+      end
+
+      def rename_text_search_parser(old_name, new_name)
+        execute("ALTER TEXT SEARCH PARSER %s RENAME TO %s;" % [
+          quote_generic_with_schema(old_name),
+          quote_generic_with_schema(new_name)
+        ])
+      end
+
+      def alter_text_search_parser_schema(name, schema)
+        execute "ALTER TEXT SEARCH PARSER #{quote_generic_with_schema(name)} SET SCHEMA #{quote_schema(schema)};"
+      end
+
+      private
+        def extract_hash_or_array_options(hash_or_array, *keys)
+          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