sequel 2.6.0 → 2.7.0

data/lib/sequel_model/eager_loading.rb

@@ -128,32 +128,13 @@ module Sequel::Model::Associations::EagerLoading
     klass = r.associated_class
     assoc_name = r[:name]
     assoc_table_alias = ds.eager_unique_table_alias(ds, assoc_name)
-    join_type = r[:graph_join_type]
-    conditions = r[:graph_conditions]
-    use_only_conditions = r.include?(:graph_only_conditions)
-    only_conditions = r[:graph_only_conditions]
-    select = r[:graph_select]
-    graph_block = r[:graph_block]
-    ds = case assoc_type = r[:type]
-    when :many_to_one
-      ds.graph(klass, use_only_conditions ? only_conditions : [[klass.primary_key, r[:key].qualify(ta)]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type, &graph_block)
-    when :one_to_many
-      ds = ds.graph(klass, use_only_conditions ? only_conditions : [[r[:key], model.primary_key.qualify(ta)]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type, &graph_block)
-      # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
-      ds.opts[:eager_graph][:reciprocals][assoc_table_alias] = r.reciprocal
-      ds
-    when :many_to_many
-      use_jt_only_conditions = r.include?(:graph_join_table_only_conditions)
-      ds = ds.graph(r[:join_table], use_jt_only_conditions ? r[:graph_join_table_only_conditions] : [[r[:left_key], model.primary_key.qualify(ta)]] + r[:graph_join_table_conditions], :select=>false, :table_alias=>ds.eager_unique_table_alias(ds, r[:join_table]), :join_type=>r[:graph_join_table_join_type], &r[:graph_join_table_block])
-      ds.graph(klass, use_only_conditions ? only_conditions : [[klass.primary_key, r[:right_key]]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type, &graph_block)
-    end
-
+    ds = r[:eager_grapher].call(ds, assoc_table_alias, ta)
     ds = ds.order_more(*Array(r[:order]).map{|c| eager_graph_qualify_order(assoc_table_alias, c)}) if r[:order] and r[:order_eager_graph]
     eager_graph = ds.opts[:eager_graph]
     eager_graph[:requirements][assoc_table_alias] = requirements.dup
     eager_graph[:alias_association_name_map][assoc_table_alias] = assoc_name
-    eager_graph[:alias_association_type_map][assoc_table_alias] = assoc_type
-    ds = ds.eager_graph_associations(ds, klass, assoc_table_alias, requirements + [assoc_table_alias], *associations) unless associations.empty?
+    eager_graph[:alias_association_type_map][assoc_table_alias] = r.returns_array?
+    ds = ds.eager_graph_associations(ds, r.associated_class, assoc_table_alias, requirements + [assoc_table_alias], *associations) unless associations.empty?
     ds
   end
 
@@ -240,7 +221,7 @@ module Sequel::Model::Associations::EagerLoading
     end
 
     # Remove duplicate records from all associations if this graph could possibly be a cartesian product
-    eager_graph_make_associations_unique(records, dependency_map, alias_map, type_map) if type_map.reject{|k,v| v == :many_to_one}.length > 1
+    eager_graph_make_associations_unique(records, dependency_map, alias_map, type_map) if type_map.values.select{|v| v}.length > 1
     
     # Replace the array of object graphs with an array of model objects
     record_graphs.replace(records)
@@ -286,7 +267,7 @@ module Sequel::Model::Associations::EagerLoading
     # Don't clobber the instance variable array for *_to_many associations if it has already been setup
     dependency_map.keys.each do |ta|
       assoc_name = alias_map[ta]
-      current.associations[assoc_name] = type_map[ta] == :many_to_one ? nil : [] unless current.associations.include?(assoc_name)
+      current.associations[assoc_name] = type_map[ta] ? [] : nil unless current.associations.include?(assoc_name)
     end
     dependency_map.each do |ta, deps|
       next unless rec = record_graph[ta]
@@ -297,12 +278,12 @@ module Sequel::Model::Associations::EagerLoading
         records_map[ta][rec.pk] = rec
       end
       assoc_name = alias_map[ta]
-      case assoc_type = type_map[ta]
-      when :many_to_one
+      case type_map[ta]
+      when false
         current.associations[assoc_name] = rec
       else
         current.associations[assoc_name].push(rec) 
-        if assoc_type == :one_to_many and reciprocal = reciprocal_map[ta]
+        if reciprocal = reciprocal_map[ta]
           rec.associations[reciprocal] = current
         end
       end
@@ -319,7 +300,7 @@ module Sequel::Model::Associations::EagerLoading
   def eager_graph_make_associations_unique(records, dependency_map, alias_map, type_map)
     records.each do |record|
       dependency_map.each do |ta, deps|
-        list = if type_map[ta] == :many_to_one
+        list = if !type_map[ta]
           item = record.send(alias_map[ta])
           [item] if item
         else
@@ -361,27 +342,23 @@ module Sequel::Model::Associations::EagerLoading
     #  and values being an array of current model objects with that
     #  specific foreign/primary key
     key_hash = {}
-    # array of attribute_values keys to monitor
-    keys = []
     # Reflections for all associations to eager load
     reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc)}
 
     # Populate keys to monitor
-    reflections.each do |reflection|
-      key = reflection[:type] == :many_to_one ? reflection[:key] : model.primary_key
-      next if key_hash[key]
-      key_hash[key] = {}
-      keys << key
-    end
+    reflections.each{|reflection| key_hash[reflection.eager_loader_key] ||= Hash.new{|h,k| h[k] = []}}
     
     # Associate each object with every key being monitored
-    a.each do |r|
-      keys.each do |key|
-        ((key_hash[key][r[key]] ||= []) << r) if r[key]
+    a.each do |rec|
+      key_hash.each do |key, id_map|
+        id_map[rec[key]] << rec if rec[key]
       end
     end
     
-    reflections.each{|r| r[:eager_loader].call(key_hash, a, eager_assoc[r[:name]])}
+    reflections.each do |r|
+      r[:eager_loader].call(key_hash, a, eager_assoc[r[:name]])
+      a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} unless r[:after_load].empty?
+    end 
   end
 
   # Build associations from the graph if #eager_graph was used, 

data/lib/sequel_model/hooks.rb

@@ -8,12 +8,14 @@ module Sequel
     # Hooks that are only for internal use
     PRIVATE_HOOKS = [:before_update_values, :before_delete]
     
-    # Returns true if the model class or any of its ancestors have defined
-    # hooks for the given hook key. Notice that this method cannot detect 
-    # hooks defined using overridden methods.
-    def self.has_hooks?(key)
-      has = hooks[key] && !hooks[key].empty?
-      has || ((self != Model) && superclass.has_hooks?(key))
+    # Returns true if there are any hook blocks for the given hook.
+    def self.has_hooks?(hook)
+      !@hooks[hook].empty?
+    end
+
+    # Yield every block related to the given hook.
+    def self.hook_blocks(hook)
+      @hooks[hook].each{|k,v| yield v}
     end
 
     ### Private Class Methods ###
@@ -26,7 +28,7 @@ module Sequel
         (raise Error, 'No hook method specified') unless tag
         block = proc {send tag}
       end
-      h = hooks[hook]
+      h = @hooks[hook]
       if tag && (old = h.find{|x| x[0] == tag})
         old[1] = block
       else
@@ -34,28 +36,27 @@ module Sequel
       end
     end
 
-    # Returns all hook methods for the given type of hook for this
-    # model class and its ancestors.
-    def self.all_hooks(hook) # :nodoc:
-      ((self == Model ? [] : superclass.send(:all_hooks, hook)) + hooks[hook].collect{|x| x[1]})
-    end
-      
-    # Returns the hooks hash for this model class.
-    def self.hooks #:nodoc:
-      @hooks ||= Hash.new {|h, k| h[k] = []}
+    # Define a hook instance method that calls the run_hooks instance method.
+    def self.define_hook_instance_method(hook) #:nodoc:
+      class_eval("def #{hook}; run_hooks(:#{hook}); end")
     end
 
-    # Runs all hooks of type hook on the given object.
-    # Returns false if any hook returns false.
-    def self.run_hooks(hook, object) #:nodoc:
-      all_hooks(hook).each{|b| return false if object.instance_eval(&b) == false}
-    end
+    private_class_method :add_hook, :define_hook_instance_method
 
-    private_class_method :add_hook, :all_hooks, :hooks, :run_hooks
+    private 
 
+    # Runs all hook blocks of given hook type on this object.
+    # Stops running hook blocks and returns false if any hook block returns false.
+    def run_hooks(hook)
+      model.hook_blocks(hook){|block| return false if instance_eval(&block) == false}
+    end
+    
+    # For performance reasons, we define empty hook instance methods, which are
+    # overwritten with real hook instance methods whenever the hook class method is called.
     (HOOKS + PRIVATE_HOOKS).each do |hook|
-      instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end")
-      define_method(hook){model.send(:run_hooks, hook, self)}
+      @hooks[hook] = []
+      instance_eval("def #{hook}(method = nil, &block); define_hook_instance_method(:#{hook}); add_hook(:#{hook}, method, &block) end")
+      class_eval("def #{hook}; end")
     end
   end
 end

data/lib/sequel_model/record.rb

@@ -12,35 +12,18 @@ module Sequel
     # The columns that have been updated.  This isn't completely accurate,
     # see Model#[]=.
     attr_reader :changed_columns
-    
-    # Whether this model instance should raise an exception instead of
-    # returning nil on a failure to save/save_changes/etc.
-    attr_writer :raise_on_save_failure
-
-    # Whether this model instance should raise an error when it cannot typecast
-    # data for a column correctly.
-    attr_writer :raise_on_typecast_failure
-
-    # Whether this model instance should raise an error if attempting
-    # to call a method through set/update and their variants that either
-    # doesn't exist or access to it is denied.
-    attr_writer :strict_param_setting
-
-    # Whether this model instance should typecast the empty string ('') to
-    # nil for columns that are non string or blob.
-    attr_writer :typecast_empty_string_to_nil
-
-    # Whether this model instance should typecast on attribute assignment
-    attr_writer :typecast_on_assignment
 
     # The hash of attribute values.  Keys are symbols with the names of the
     # underlying database columns.
     attr_reader :values
 
     class_attr_reader :columns, :dataset, :db, :primary_key, :str_columns
+    class_attr_overridable :db_schema, :raise_on_save_failure, :raise_on_typecast_failure, :strict_param_setting, :typecast_empty_string_to_nil, :typecast_on_assignment
+    remove_method :db_schema=
     
     # Creates new instance with values set to passed-in Hash.
-    # If a block is given, yield the instance to the block.
+    # If a block is given, yield the instance to the block unless
+    # from_db is true.
     # This method runs the after_initialize hook after
     # it has optionally yielded itself to the block.
     #
@@ -49,16 +32,9 @@ module Sequel
     #   string keys will work if from_db is false.
     # * from_db - should only be set by Model.load, forget it
     #   exists.
-    def initialize(values = nil, from_db = false, &block)
-      values ||=  {}
+    def initialize(values = {}, from_db = false, &block)
       @associations = {}
-      @db_schema = model.db_schema
       @changed_columns = []
-      @raise_on_save_failure = model.raise_on_save_failure
-      @strict_param_setting = model.strict_param_setting
-      @typecast_on_assignment = model.typecast_on_assignment
-      @typecast_empty_string_to_nil = model.typecast_empty_string_to_nil
-      @raise_on_typecast_failure = model.raise_on_typecast_failure
       if from_db
         @new = false
         @values = values
@@ -66,10 +42,9 @@ module Sequel
         @values = {}
         @new = true
         set(values)
+        @changed_columns.clear 
+        yield self if block
       end
-      @changed_columns.clear 
-      
-      yield self if block
       after_initialize
     end
     
@@ -391,12 +366,11 @@ module Sequel
     # Add/Set the current object to/as the given object's reciprocal association.
     def add_reciprocal_object(opts, o)
       return unless reciprocal = opts.reciprocal
-      case opts[:type]
-      when :many_to_many, :many_to_one
+      if opts.reciprocal_array?
         if array = o.associations[reciprocal] and !array.include?(self)
           array.push(self)
         end
-      when :one_to_many
+      else
         o.associations[reciprocal] = self
       end
     end
@@ -407,14 +381,14 @@ module Sequel
       if @associations.include?(name) and !reload
         @associations[name]
       else
-        objs = if opts.single_associated_object?
+        objs = if opts.returns_array?
+          send(opts.dataset_method).all
+        else
           if !opts[:key]
             send(opts.dataset_method).all.first
           elsif send(opts[:key])
             send(opts.dataset_method).first
           end
-        else
-          objs = send(opts.dataset_method).all
         end
         run_association_callbacks(opts, :after_load, objs)
         # Only one_to_many associations should set the reciprocal object
@@ -447,21 +421,19 @@ module Sequel
     # Remove/unset the current object from/as the given object's reciprocal association.
     def remove_reciprocal_object(opts, o)
       return unless reciprocal = opts.reciprocal
-      case opts[:type]
-      when :many_to_many, :many_to_one
+      if opts.reciprocal_array?
         if array = o.associations[reciprocal]
           array.delete_if{|x| self === x}
         end
-      when :one_to_many
+      else
         o.associations[reciprocal] = nil
       end
     end
 
     # Run the callback for the association with the object.
     def run_association_callbacks(reflection, callback_type, object)
-      raise_error = @raise_on_save_failure
-      raise_error = true if reflection[:type] == :many_to_one
-      stop_on_false = true if [:before_add, :before_remove].include?(callback_type)
+      raise_error = raise_on_save_failure || !reflection.returns_array?
+      stop_on_false = [:before_add, :before_remove].include?(callback_type)
       reflection[callback_type].each do |cb|
         res = case cb
         when Symbol
@@ -480,7 +452,7 @@ module Sequel
 
     # Raise an error if raise_on_save_failure is true
     def save_failure(action, raise_error = nil)
-      raise_error = @raise_on_save_failure if raise_error.nil?
+      raise_error = raise_on_save_failure if raise_error.nil?
       raise(Error, "unable to #{action} record") if raise_error
     end
 
@@ -488,14 +460,14 @@ module Sequel
     def set_restricted(hash, only, except)
       columns_not_set = model.instance_variable_get(:@columns).blank?
       meths = setter_methods(only, except)
-      strict_param_setting = @strict_param_setting
+      strict = strict_param_setting
       hash.each do |k,v|
         m = "#{k}="
         if meths.include?(m)
           send(m, v)
         elsif columns_not_set && (Symbol === k)
           self[k] = v
-        elsif strict_param_setting
+        elsif strict
           raise Error, "method #{m} doesn't exist or access is restricted to it"
         end
       end
@@ -535,13 +507,13 @@ module Sequel
     # typecast_value method, so database adapters can override/augment the handling
     # for database specific column types.
     def typecast_value(column, value)
-      return value unless @typecast_on_assignment && @db_schema && (col_schema = @db_schema[column])
-      value = nil if value == '' and @typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type])
-      raise(Error::InvalidValue, "nil/NULL is not allowed for the #{column} column") if @raise_on_typecast_failure && value.nil? && (col_schema[:allow_null] == false)
+      return value unless typecast_on_assignment && db_schema && (col_schema = db_schema[column]) && !model.serialized?(column)
+      value = nil if value == '' and typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type])
+      raise(Error::InvalidValue, "nil/NULL is not allowed for the #{column} column") if raise_on_typecast_failure && value.nil? && (col_schema[:allow_null] == false)
       begin
         model.db.typecast_value(col_schema[:type], value)
       rescue Error::InvalidValue
-        if @raise_on_typecast_failure
+        if raise_on_typecast_failure
           raise
         else
           value
@@ -549,6 +521,12 @@ module Sequel
       end
     end
 
+    # Call uniq! on the given array. This is used by the :uniq option,
+    # and is an actual method for memory reasons.
+    def array_uniq!(a)
+      a.uniq!
+    end
+
     # Set the columns, filtered by the only and except arrays.
     def update_restricted(hash, only, except)
       set_restricted(hash, only, except)

data/lib/sequel_model/schema.rb

@@ -3,7 +3,7 @@ module Sequel
     # Creates table, using the column information from set_schema.
     def self.create_table
       db.create_table(table_name, @schema)
-      @db_schema = get_db_schema(true) unless @@lazy_load_schema
+      @db_schema = get_db_schema(true)
       columns
     end
     

data/lib/sequel_model/validations.rb

@@ -18,6 +18,11 @@ module Sequel
         def add(att, msg)
           self[att] << msg
         end
+
+        # Return the total number of error messages.
+        def count
+          full_messages.length
+        end
         
         # Returns an array of fully-formatted error messages.
         def full_messages
@@ -28,9 +33,10 @@ module Sequel
           end
         end
         
-        # Returns the errors for the given attribute.
+        # Returns the array of errors for the given attribute, or nil
+        # if there are no errors for the attribute.
         def on(att)
-          self[att]
+          self[att] if include?(att)
         end
       end
   
@@ -304,7 +310,11 @@ module Sequel
     end
 
     # Validates only if the fields in the model (specified by atts) are
-    # unique in the database.  You should also add a unique index in the
+    # unique in the database.  Pass an array of fields instead of multiple
+    # fields to specify that the combination of fields must be unique,
+    # instead of that each field should have a unique value.
+    #
+    # You should also add a unique index in the
     # database, as this suffers from a fairly obvious race condition.
     #
     # Possible Options:

data/spec/adapters/postgres_spec.rb

@@ -343,8 +343,8 @@ context "A PostgreSQL database" do
       full_text_index [:title, :body]
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (title text, body text)",
-      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', title || body))"
+      "CREATE TABLE public.posts (title text, body text)",
+      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
     ]
   end
   
@@ -355,20 +355,20 @@ context "A PostgreSQL database" do
       full_text_index [:title, :body], :language => 'french'
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (title text, body text)",
-      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('french', title || body))"
+      "CREATE TABLE public.posts (title text, body text)",
+      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('french', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
     ]
   end
   
   specify "should support full_text_search" do
     POSTGRES_DB[:posts].full_text_search(:title, 'ruby').sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector(title) @@ to_tsquery('ruby'))"
+      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, ''))) @@ to_tsquery('simple', 'ruby'))"
     
     POSTGRES_DB[:posts].full_text_search([:title, :body], ['ruby', 'sequel']).sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector(title || body) @@ to_tsquery('ruby | sequel'))"
+      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))) @@ to_tsquery('simple', 'ruby | sequel'))"
       
     POSTGRES_DB[:posts].full_text_search(:title, 'ruby', :language => 'french').sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector('french', title) @@ to_tsquery('french', 'ruby'))"
+      "SELECT * FROM posts WHERE (to_tsvector('french', (COALESCE(title, ''))) @@ to_tsquery('french', 'ruby'))"
   end
 
   specify "should support spatial indexes" do
@@ -377,7 +377,7 @@ context "A PostgreSQL database" do
       spatial_index [:geom]
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (geom geometry)",
+      "CREATE TABLE public.posts (geom geometry)",
       "CREATE INDEX posts_geom_index ON posts USING gist (geom)"
     ]
   end
@@ -388,7 +388,7 @@ context "A PostgreSQL database" do
       index :title, :type => 'hash'
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (title varchar(5))",
+      "CREATE TABLE public.posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
@@ -399,7 +399,7 @@ context "A PostgreSQL database" do
       index :title, :type => 'hash', :unique => true
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (title varchar(5))",
+      "CREATE TABLE public.posts (title varchar(5))",
       "CREATE UNIQUE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
@@ -410,7 +410,7 @@ context "A PostgreSQL database" do
       index :title, :where => {:something => 5}
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (title varchar(5))",
+      "CREATE TABLE public.posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts (title) WHERE (something = 5)"
     ]
   end
@@ -496,22 +496,108 @@ context "Postgres::Dataset#insert" do
   end
 end
 
+context "Postgres::Database schema qualified tables" do
+  setup do
+    POSTGRES_DB << "CREATE SCHEMA schema_test"
+    POSTGRES_DB.instance_variable_set(:@primary_keys, {})
+    POSTGRES_DB.instance_variable_set(:@primary_key_sequences, {})
+  end
+  teardown do
+    POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
+    POSTGRES_DB.default_schema = :public
+  end
+  
+  specify "should be able to create, drop, select and insert into tables in a given schema" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
+    POSTGRES_DB[:schema_test__schema_test].first.should == nil
+    POSTGRES_DB[:schema_test__schema_test].insert(:i=>1).should == 1
+    POSTGRES_DB[:schema_test__schema_test].first.should == {:i=>1}
+    POSTGRES_DB.from('schema_test.schema_test'.lit).first.should == {:i=>1}
+    POSTGRES_DB.drop_table(:schema_test__schema_test)
+    POSTGRES_DB.create_table(:schema_test.qualify(:schema_test)){integer :i}
+    POSTGRES_DB[:schema_test__schema_test].first.should == nil
+    POSTGRES_DB.from('schema_test.schema_test'.lit).first.should == nil
+    POSTGRES_DB.drop_table(:schema_test.qualify(:schema_test))
+  end
+  
+  specify "#tables should include only tables in the public schema if no schema is given" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
+    POSTGRES_DB.tables.should_not include(:schema_test)
+  end
+  
+  specify "#tables should return tables in the schema provided by the :schema argument" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
+    POSTGRES_DB.tables(:schema=>:schema_test).should == [:schema_test]
+  end
+  
+  specify "#table_exists? should assume the public schema if no schema is provided" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
+    POSTGRES_DB.table_exists?(:schema_test).should == false
+  end
+  
+  specify "#table_exists? should see if the table is in a given schema" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
+    POSTGRES_DB.table_exists?(:schema_test__schema_test).should == true
+  end
+  
+  specify "should be able to get primary keys for tables in a given schema" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
+    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_for_table, c, :schema_test__schema_test).should == 'i'}
+  end
+  
+  specify "should be able to get serial sequences for tables in a given schema" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
+    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_sequence_for_table, c, :schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'}
+  end
+  
+  specify "should be able to get custom sequences for tables in a given schema" do
+    POSTGRES_DB << "CREATE SEQUENCE schema_test.kseq"
+    POSTGRES_DB.create_table(:schema_test__schema_test){integer :j; primary_key :k, :type=>:integer, :default=>"nextval('schema_test.kseq'::regclass)".lit}
+    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_sequence_for_table, c, :schema_test__schema_test).should == '"schema_test"."kseq"'}
+  end
+  
+  specify "#default_schema= should change the default schema used from public" do
+    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
+    POSTGRES_DB.default_schema = :schema_test
+    POSTGRES_DB.table_exists?(:schema_test).should == true
+    POSTGRES_DB.tables.should == [:schema_test]
+    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_for_table, c, :schema_test).should == 'i'}
+    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_sequence_for_table, c, :schema_test).should == '"schema_test"."schema_test_i_seq"'}
+  end
+end
+
 if POSTGRES_DB.server_version >= 80300
 
   POSTGRES_DB.create_table! :test6 do
     text :title
-    full_text_index [:title]
+    text :body
+    full_text_index [:title, :body]
   end
 
   context "PostgreSQL tsearch2" do
+    before do
+      @ds = POSTGRES_DB[:test6]
+    end
+    after do
+      POSTGRES_DB[:test6].delete
+    end
 
     specify "should search by indexed column" do
-      # tsearch is by default included from PostgreSQL 8.3
-      ds = POSTGRES_DB[:test6]
-      record = {:title => "oopsla conference"}
-      ds << record
-      actual = ds.full_text_search(:title, "oopsla")
-      actual.should include(record)
+      record =  {:title => "oopsla conference", :body => "test"}
+      @ds << record
+      @ds.full_text_search(:title, "oopsla").all.should include(record)
+    end
+
+    specify "should join multiple coumns with spaces to search by last words in row" do
+      record = {:title => "multiple words", :body => "are easy to search"}
+      @ds << record
+      @ds.full_text_search([:title, :body], "words").all.should include(record)
+    end
+
+    specify "should return rows with a NULL in one column if a match in another column" do
+      record = {:title => "multiple words", :body =>nil}
+      @ds << record
+      @ds.full_text_search([:title, :body], "words").all.should include(record)
     end
   end
 end