sequel 2.5.0 → 2.6.0

data/lib/sequel_core/sql.rb

@@ -481,11 +481,14 @@ module Sequel
       # The default value if no conditions are true
       attr_reader :default
 
+      # The expression to test the conditions against
+      attr_reader :expression
+
       # Create an object with the given conditions and
       # default value.
-      def initialize(conditions, default)
+      def initialize(conditions, default, expression = nil)
         raise(Sequel::Error, 'CaseExpression conditions must be an array with all_two_pairs') unless Array === conditions and conditions.all_two_pairs?
-        @conditions, @default = conditions, default
+        @conditions, @default, @expression = conditions, default, expression
       end
 
       # Delegate the creation of the resulting SQL to the given dataset,

data/lib/sequel_model.rb

@@ -50,8 +50,9 @@ module Sequel
   #   cache_store, cache_ttl, dataset_methods, primary_key, restricted_columns,
   #   sti_dataset, and sti_key.  You should not usually need to
   #   access these directly.
-  # * The following class level attr_accessors are created: raise_on_save_failure,
-  #   strict_param_setting, typecast_empty_string_to_nil, and typecast_on_assignment:
+  # * The following class level attr_accessors are created: raise_on_typecast_failure,
+  #   raise_on_save_failure, strict_param_setting, typecast_empty_string_to_nil,
+  #   and typecast_on_assignment:
   #
   #     # Don't raise an error if a validation attempt fails in
   #     # save/create/save_changes/etc.
@@ -72,6 +73,11 @@ module Sequel
   #     Model.typecast_empty_string_to_nil = false
   #     m.number = ''
   #     m.number # => '' instead of nil
+  #     # Don't raise if unable to typecast data for a column
+  #     Model.typecast_empty_string_to_nil = true
+  #     Model.raise_on_typecast_failure = false
+  #     m.not_null_column = '' # => nil
+  #     m.number = 'A' # => 'A'
   #
   # * The following class level method aliases are defined:
   #   * Model.dataset= => set_dataset

data/lib/sequel_model/associations.rb

@@ -135,6 +135,8 @@ module Sequel::Model::Associations
   #     an array with two arguments for the value to specify a limit and offset.
   #   - :order - the column(s) by which to order the association dataset.  Can be a
   #     singular column or an array.
+  #   - :order_eager_graph - Whether to add the order to the dataset's order when graphing
+  #     via eager graph.  Defaults to true, so set to false to disable.
   #   - :read_only - Do not add a setter method (for many_to_one or one_to_many with :one_to_one),
   #     or add_/remove_/remove_all_ methods (for one_to_many, many_to_many)
   #   - :reciprocal - the symbol name of the reciprocal association,
@@ -192,6 +194,7 @@ module Sequel::Model::Associations
     opts = AssociationReflection.new.merge!(opts)
     opts[:eager_block] = block unless opts.include?(:eager_block)
     opts[:graph_join_type] ||= :left_outer
+    opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
     opts[:graph_conditions] = opts[:graph_conditions] ? opts[:graph_conditions].to_a : []
     opts[:graph_select] = Array(opts[:graph_select]) if opts[:graph_select]
     [:before_add, :before_remove, :after_add, :after_remove, :after_load, :extend].each do |cb_type|
@@ -325,12 +328,12 @@ module Sequel::Model::Associations
     opts[:eager_loader] ||= proc do |key_hash, records, associations|
       h = key_hash[key]
       keys = h.keys
+      # Default the cached association to nil, so any object that doesn't have it
+      # populated will have cached the negative lookup.
+      records.each{|object| object.associations[name] = nil}
       # Skip eager loading if no objects have a foreign key for this association
       unless keys.empty?
-        # Default the cached association to nil, so any object that doesn't have it
-        # populated will have cached the negative lookup.
-        records.each{|object| object.associations[name] = nil}
-        model.eager_loading_dataset(opts, opts.associated_class.filter(opts.associated_primary_key.qualify(opts.associated_class.table_name)=>keys),  opts.select, associations).all do |assoc_record|
+        model.eager_loading_dataset(opts, opts.associated_class.filter(opts.associated_primary_key.qualify(opts.associated_class.table_name)=>keys), opts.select, associations).all do |assoc_record|
           next unless objects = h[assoc_record.pk]
           objects.each{|object| object.associations[name] = assoc_record}
         end

data/lib/sequel_model/base.rb

@@ -9,6 +9,7 @@ module Sequel
     @dataset_methods = {}
     @primary_key = :id
     @raise_on_save_failure = true
+    @raise_on_typecast_failure = true
     @restrict_primary_key = true
     @restricted_columns = nil
     @sti_dataset = nil
@@ -32,6 +33,10 @@ module Sequel
     # to save/create/save_changes/etc.
     metaattr_accessor :raise_on_save_failure
 
+    # Whether to raise an error when unable to typecast data for a column
+    # (default: true)
+    metaattr_accessor :raise_on_typecast_failure
+
     # Which columns should not be update in a call to set
     # (default: no columns).
     metaattr_reader :restricted_columns
@@ -70,7 +75,8 @@ module Sequel
       :@cache_ttl=>nil, :@dataset_methods=>:dup, :@primary_key=>nil, 
       :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
       :@sti_dataset=>nil, :@sti_key=>nil, :@strict_param_setting=>nil,
-      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil}
+      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
+      :@raise_on_typecast_failure=>nil}
 
     # Returns the first record from the database matching the conditions.
     # If a hash is given, it is used as the conditions.  If another
@@ -470,6 +476,9 @@ module Sequel
           # returned by the schema.
           cols = schema_array.collect{|k,v| k}
           set_columns(cols)
+          # Set the primary key(s) based on the schema information
+          pks = schema_array.collect{|k,v| k if v[:primary_key]}.compact
+          pks.length > 0 ? set_primary_key(*pks) : no_primary_key
           # Also set the columns for the dataset, so the dataset
           # doesn't have to do a query to get them.
           dataset.instance_variable_set(:@columns, cols)

data/lib/sequel_model/eager_loading.rb

@@ -87,10 +87,8 @@ module Sequel::Model::Associations::EagerLoading
   # create large cartesian products.  If you must graph multiple *_to_many associations,
   # make sure your filters are specific if you have a large database.
   # 
-  # This does not respect each association's order, as all associations are loaded in
-  # a single query.  If you want to order the results, you must manually call .order.
-  #
-  # #eager_graph probably won't work correctly on a limited dataset, unless you are
+  # Each association's order, if definied, is respected. #eager_graph probably
+  # won't work correctly on a limited dataset, unless you are
   # only graphing many_to_one associations.
   # 
   # Does not use the block defined for the association, since it does a single query for
@@ -149,6 +147,8 @@ module Sequel::Model::Associations::EagerLoading
       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 = 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
@@ -250,16 +250,18 @@ module Sequel::Model::Associations::EagerLoading
   # Will either be the table_alias itself or table_alias_N for some integer
   # N (starting at 0 and increasing until an unused one is found).
   def eager_unique_table_alias(ds, table_alias)
-    if (graph = ds.opts[:graph]) && (table_aliases = graph[:table_aliases]) && (table_aliases.include?(table_alias))
+    used_aliases = ds.opts[:from]
+    graph = ds.opts[:graph]
+    used_aliases += graph[:table_aliases].keys if graph
+    if used_aliases.include?(table_alias)
       i = 0
       loop do
         ta = :"#{table_alias}_#{i}"
-        return ta unless table_aliases[ta]
+        return ta unless used_aliases.include?(ta)
         i += 1
       end
-    else
-      table_alias
     end
+    table_alias
   end
 
   private
@@ -323,13 +325,30 @@ module Sequel::Model::Associations::EagerLoading
         else
           list = record.send(alias_map[ta])
           list.uniq!
-          # Recurse into dependencies
-          list.each{|rec| eager_graph_make_associations_unique(rec, deps, alias_map, type_map)}
         end
+        # Recurse into dependencies
+        eager_graph_make_associations_unique(list, deps, alias_map, type_map) if list
       end
     end
   end
 
+  # Qualify the given expression if necessary.  The only expressions which are qualified are
+  # unqualified symbols and identifiers, either of which may by sorted.
+  def eager_graph_qualify_order(table_alias, expression)
+    case expression
+    when Symbol
+      table, column, aliaz = split_symbol(expression)
+      raise(Sequel::Error, "Can't use an aliased expression in the :order option") if aliaz
+      table ? expression : Sequel::SQL::QualifiedIdentifier.new(table_alias, expression)
+    when Sequel::SQL::Identifier
+      Sequel::SQL::QualifiedIdentifier.new(table_alias, expression)
+    when Sequel::SQL::OrderedExpression
+      Sequel::SQL::OrderedExpression.new(eager_graph_qualify_order(table_alias, expression.expression), expression.descending)
+    else
+      expression
+    end
+  end
+
   # Eagerly load all specified associations 
   def eager_load(a)
     return if a.empty?

data/lib/sequel_model/record.rb

@@ -2,7 +2,7 @@ module Sequel
   class Model
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via set.
-    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure="
+    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure= raise_on_typecast_failure="
 
     # The current cached associations.  A hash with the keys being the
     # association name symbols and the values being the associated object
@@ -17,6 +17,10 @@ module Sequel
     # 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.
@@ -54,6 +58,7 @@ module Sequel
       @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
@@ -199,7 +204,8 @@ module Sequel
     # Creates or updates the record, after making sure the record
     # is valid.  If the record is not valid, or before_save,
     # before_create (if new?), or before_update (if !new?) return
-    # false, returns nil unless raise_on_save_failure is true.
+    # false, returns nil unless raise_on_save_failure is true (if it
+    # is true, it raises an error).
     # Otherwise, returns self. You can provide an optional list of
     # columns to update, in which case it only updates those columns.
     def save(*columns)
@@ -212,7 +218,7 @@ module Sequel
     # in which case it only updates those columns.
     # If before_save, before_create (if new?), or before_update
     # (if !new?) return false, returns nil unless raise_on_save_failure
-    # is true.  Otherwise, returns self.
+    # is true (if it is true, it raises an error).  Otherwise, returns self.
     def save!(*columns)
       opts = columns.extract_options!
       return save_failure(:save) if before_save == false
@@ -531,8 +537,16 @@ module Sequel
     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, "nil/NULL is not allowed for the #{column} column") if value.nil? && (col_schema[:allow_null] == false)
-      model.db.typecast_value(col_schema[:type], value)
+      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
+          raise
+        else
+          value
+        end
+      end
     end
 
     # Set the columns, filtered by the only and except arrays.

data/spec/adapters/mysql_spec.rb

@@ -69,10 +69,10 @@ context "A MySQL database" do
   end
 
   specify "should correctly parse the schema" do
-    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"tinyint", :numeric_precision=>3}]]
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :primary_key=>false, :default=>nil, :db_type=>"tinyint(4)"}]]
     
     Sequel.convert_tinyint_to_bool = false
-    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"tinyint", :numeric_precision=>3}]]
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :db_type=>"tinyint(4)"}]]
   end
 
   specify "should get the schema all database tables if no table name is used" do

data/spec/adapters/postgres_spec.rb

@@ -47,13 +47,14 @@ context "A PostgreSQL database" do
   end
 
   specify "should correctly parse the schema" do
+    require 'logger'
     @db.schema(:test3, :reload=>true).should == [
-      [:value, {:type=>:integer, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"integer", :numeric_precision=>32}],
-      [:time, {:type=>:datetime, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"timestamp without time zone", :numeric_precision=>nil}]
+      [:value, {:type=>:integer, :allow_null=>true, :default=>nil, :db_type=>"integer", :primary_key=>false}],
+      [:time, {:type=>:datetime, :allow_null=>true, :default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
     ]
     @db.schema(:test4, :reload=>true).should == [
-      [:name, {:type=>:string, :allow_null=>true, :max_chars=>20, :default=>nil, :db_type=>"character varying", :numeric_precision=>nil}],
-      [:value, {:type=>:blob, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"bytea", :numeric_precision=>nil}]
+      [:name, {:type=>:string, :allow_null=>true, :default=>nil, :db_type=>"character varying(20)", :primary_key=>false}],
+      [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :db_type=>"bytea", :primary_key=>false}]
     ]
   end
 
@@ -343,7 +344,7 @@ context "A PostgreSQL database" do
     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(title || body))"
+      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', title || body))"
     ]
   end
   
@@ -494,3 +495,23 @@ context "Postgres::Dataset#insert" do
     ds.insert(:name=>'a').should == nil
   end
 end
+
+if POSTGRES_DB.server_version >= 80300
+
+  POSTGRES_DB.create_table! :test6 do
+    text :title
+    full_text_index [:title]
+  end
+
+  context "PostgreSQL tsearch2" do
+
+    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)
+    end
+  end
+end

data/spec/adapters/sqlite_spec.rb

@@ -9,6 +9,9 @@ context "An SQLite database" do
   before do
     @db = SQLITE_DB
   end
+  after do
+    Sequel.datetime_class = Time
+  end
 
   if SQLITE_DB.auto_vacuum == :none
     specify "should support getting pragma values" do
@@ -128,12 +131,17 @@ context "An SQLite database" do
     @db[:items2].count.should == 2
   end
 
-  specify "should support timestamps" do
-    t1 = Time.at(Time.now.to_i) #normalize time
-    @db.create_table!(:time) {timestamp :t}
-    @db[:time] << {:t => t1}
-    x = @db[:time].first[:t]
-    [t1.iso8601, t1.to_s].should include(x.respond_to?(:iso8601) ? x.iso8601 : x.to_s)
+  specify "should support timestamps and datetimes and respect datetime_class" do
+    @db.create_table!(:time){timestamp :t; datetime :d}
+    t1 = Time.at(1)
+    @db[:time] << {:t => t1, :d => t1.to_i}
+    @db[:time] << {:t => t1.to_i, :d => t1}
+    @db[:time].map(:t).should == [t1, t1]
+    @db[:time].map(:d).should == [t1, t1]
+    t2 = t1.iso8601.to_datetime
+    Sequel.datetime_class = DateTime
+    @db[:time].map(:t).should == [t2, t2]
+    @db[:time].map(:d).should == [t2, t2]
   end
   
   specify "should support sequential primary keys" do
@@ -159,12 +167,12 @@ context "An SQLite database" do
 
   specify "should correctly parse the schema" do
     @db.create_table!(:time2) {timestamp :t}
-    @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"timestamp", :numeric_precision=>nil, :primary_key=>false}]]
+    @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
   end
 
   specify "should get the schema all database tables if no table name is used" do
     @db.create_table!(:time2) {timestamp :t}
-    @db.schema(:time2, :reload=>true).should == @db.schema(nil, :reload=>true)[:time]
+    @db.schema(:time2, :reload=>true).should == @db.schema(nil, :reload=>true)[:time2]
   end
 end
 
@@ -240,6 +248,32 @@ context "An SQLite dataset" do
   end
 end
 
+context "An SQLite dataset AS clause" do
+  specify "should use a string literal for :col___alias" do
+    SQLITE_DB.literal(:c___a).should == "c AS 'a'"
+  end
+
+  specify "should use a string literal for :table__col___alias" do
+    SQLITE_DB.literal(:t__c___a).should == "t.c AS 'a'"
+  end
+
+  specify "should use a string literal for :column.as(:alias)" do
+    SQLITE_DB.literal(:c.as(:a)).should == "c AS 'a'"
+  end
+
+  specify "should use a string literal in the SELECT clause" do
+    SQLITE_DB[:t].select(:c___a).sql.should == "SELECT c AS 'a' FROM t"
+  end
+
+  specify "should use a string literal in the FROM clause" do
+    SQLITE_DB[:t___a].sql.should == "SELECT * FROM t AS 'a'"
+  end
+
+  specify "should use a string literal in the JOIN clause" do
+    SQLITE_DB[:t].join_table(:natural, :j, nil, :a).sql.should == "SELECT * FROM t NATURAL JOIN j AS 'a'"
+  end
+end
+
 context "An SQLite dataset" do
   setup do
     SQLITE_DB.create_table! :items do

data/spec/integration/eager_loader_test.rb

@@ -2,13 +2,12 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe "Eagerly loading a tree structure" do
   before do
+    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.create_table!(:nodes) do
+      primary_key :id
+      foreign_key :parent_id, :nodes
+    end
     class ::Node < Sequel::Model
-      set_schema do
-        primary_key :id
-        foreign_key :parent_id, :nodes
-      end
-      create_table!
-      
       many_to_one :parent
       one_to_many :children, :key=>:parent_id
     
@@ -146,11 +145,11 @@ describe "Association Extensions" do
           @opts[:models][nil].create(vals.merge(:author_id=>author_id))
       end 
     end
+    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.create_table!(:authors) do
+      primary_key :id
+    end
     class ::Author < Sequel::Model
-      set_schema do
-        primary_key :id
-      end
-      create_table!
       one_to_many :authorships, :extend=>FindOrCreate, :dataset=>(proc do
         key = pk
         ds = Authorship.filter(:author_id=>key)
@@ -160,13 +159,12 @@ describe "Association Extensions" do
         ds  
       end)
     end
+    INTEGRATION_DB.create_table!(:authorships) do
+      primary_key :id
+      foreign_key :author_id, :authors
+      text :name
+    end
     class ::Authorship < Sequel::Model
-      set_schema do
-        primary_key :id
-        foreign_key :author_id, :authors
-        text :name
-      end
-      create_table!
       many_to_one :author
     end
     @author = Author.create
@@ -212,11 +210,11 @@ end
 
 describe "has_many :through has_many and has_one :through belongs_to" do
   before do
+    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.create_table!(:firms) do
+      primary_key :id
+    end
     class ::Firm < Sequel::Model
-      set_schema do
-        primary_key :id
-      end
-      create_table!
       one_to_many :clients
       one_to_many :invoices, :read_only=>true, \
         :dataset=>proc{Invoice.eager_graph(:client).filter(:client__firm_id=>pk)}, \
@@ -237,22 +235,20 @@ describe "has_many :through has_many and has_one :through belongs_to" do
         end)
     end
 
+    INTEGRATION_DB.create_table!(:clients) do
+      primary_key :id
+      foreign_key :firm_id, :firms
+    end
     class ::Client < Sequel::Model
-      set_schema do
-        primary_key :id
-        foreign_key :firm_id, :firms
-      end
-      create_table!
       many_to_one :firm
       one_to_many :invoices
     end
 
+    INTEGRATION_DB.create_table!(:invoices) do
+      primary_key :id
+      foreign_key :client_id, :clients
+    end
     class ::Invoice < Sequel::Model
-      set_schema do
-        primary_key :id
-        foreign_key :client_id, :clients
-      end
-      create_table!
       many_to_one :client
       many_to_one :firm, :key=>nil, :read_only=>true, \
         :dataset=>proc{Firm.eager_graph(:clients).filter(:clients__id=>client_id)}, \
@@ -304,7 +300,7 @@ describe "has_many :through has_many and has_one :through belongs_to" do
 
   it "should return has_many :through has_many records for a single object" do
     invs = @firm1.invoices.sort_by{|x| x.pk}
-    sqls_should_be('SELECT invoices.id, invoices.client_id, client.id AS client_id_0, client.firm_id FROM invoices LEFT OUTER JOIN clients AS client ON (client.id = invoices.client_id) WHERE (client.firm_id = 1)')
+    sqls_should_be("SELECT invoices.id, invoices.client_id, client.id AS 'client_id_0', client.firm_id FROM invoices LEFT OUTER JOIN clients AS 'client' ON (client.id = invoices.client_id) WHERE (client.firm_id = 1)")
     invs.should == [@invoice1, @invoice2, @invoice3]
     invs[0].client.should == @client1
     invs[1].client.should == @client1
@@ -316,7 +312,7 @@ describe "has_many :through has_many and has_one :through belongs_to" do
 
   it "should eagerly load has_many :through has_many records for multiple objects" do
     firms = Firm.order(:id).eager(:invoices).all
-    sqls_should_be("SELECT * FROM firms ORDER BY id", "SELECT invoices.id, invoices.client_id, client.id AS client_id_0, client.firm_id FROM invoices LEFT OUTER JOIN clients AS client ON (client.id = invoices.client_id) WHERE (client.firm_id IN (1, 2))")
+    sqls_should_be("SELECT * FROM firms ORDER BY id", "SELECT invoices.id, invoices.client_id, client.id AS 'client_id_0', client.firm_id FROM invoices LEFT OUTER JOIN clients AS 'client' ON (client.id = invoices.client_id) WHERE (client.firm_id IN (1, 2))")
     firms.should == [@firm1, @firm2]
     firm1, firm2 = firms
     invs1 = firm1.invoices.sort_by{|x| x.pk}
@@ -337,7 +333,7 @@ describe "has_many :through has_many and has_one :through belongs_to" do
 
   it "should return has_one :through belongs_to records for a single object" do
     firm = @invoice1.firm
-    sqls_should_be('SELECT firms.id, clients.id AS clients_id, clients.firm_id FROM firms LEFT OUTER JOIN clients ON (clients.firm_id = firms.id) WHERE (clients.id = 1)')
+    sqls_should_be("SELECT firms.id, clients.id AS 'clients_id', clients.firm_id FROM firms LEFT OUTER JOIN clients ON (clients.firm_id = firms.id) WHERE (clients.id = 1)")
     firm.should == @firm1
     @invoice1.client.should == @client1
     @invoice1.client.firm.should == @firm1
@@ -347,7 +343,7 @@ describe "has_many :through has_many and has_one :through belongs_to" do
 
   it "should eagerly load has_one :through belongs_to records for multiple objects" do
     invs = Invoice.order(:id).eager(:firm).all
-    sqls_should_be("SELECT * FROM invoices ORDER BY id", "SELECT firms.id, clients.id AS clients_id, clients.firm_id FROM firms LEFT OUTER JOIN clients ON (clients.firm_id = firms.id) WHERE (clients.id IN (1, 2, 3))")
+    sqls_should_be("SELECT * FROM invoices ORDER BY id", "SELECT firms.id, clients.id AS 'clients_id', clients.firm_id FROM firms LEFT OUTER JOIN clients ON (clients.firm_id = firms.id) WHERE (clients.id IN (1, 2, 3))")
     invs.should == [@invoice1, @invoice2, @invoice3, @invoice4, @invoice5]
     invs[0].firm.should == @firm1
     invs[0].client.should == @client1
@@ -375,13 +371,13 @@ end
 
 describe "Polymorphic Associations" do
   before do
+    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.create_table!(:assets) do
+      primary_key :id
+      integer :attachable_id
+      text :attachable_type
+    end
     class ::Asset < Sequel::Model
-      set_schema do
-        primary_key :id
-        integer :attachable_id
-        text :attachable_type
-      end
-      create_table!
       many_to_one :attachable, :reciprocal=>:assets, \
         :dataset=>(proc do
           klass = attachable_type.constantize
@@ -411,11 +407,10 @@ describe "Polymorphic Associations" do
       end 
     end 
   
+    INTEGRATION_DB.create_table!(:posts) do
+      primary_key :id
+    end
     class ::Post < Sequel::Model
-      set_schema do
-        primary_key :id
-      end
-      create_table!
       one_to_many :assets, :key=>:attachable_id do |ds|
         ds.filter(:attachable_type=>'Post')
       end 
@@ -438,11 +433,10 @@ describe "Polymorphic Associations" do
       end
     end 
   
+    INTEGRATION_DB.create_table!(:notes) do
+      primary_key :id
+    end
     class ::Note < Sequel::Model
-      set_schema do
-        primary_key :id
-      end
-      create_table!
       one_to_many :assets, :key=>:attachable_id do |ds|
         ds.filter(:attachable_type=>'Note')
       end 
@@ -550,12 +544,12 @@ end
 
 describe "many_to_one/one_to_many not referencing primary key" do
   before do
+    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.create_table!(:clients) do
+      primary_key :id
+      text :name
+    end
     class ::Client < Sequel::Model
-      set_schema do
-        primary_key :id
-        text :name
-      end
-      create_table!
       one_to_many :invoices, :reciprocal=>:client, \
         :dataset=>proc{Invoice.filter(:client_name=>name)}, \
         :eager_loader=>(proc do |key_hash, clients, associations|
@@ -585,12 +579,11 @@ describe "many_to_one/one_to_many not referencing primary key" do
       end
     end 
   
+    INTEGRATION_DB.create_table!(:invoices) do
+      primary_key :id
+      text :client_name
+    end
     class ::Invoice < Sequel::Model
-      set_schema do
-        primary_key :id
-        text :client_name
-      end
-      create_table!
       many_to_one :client, :key=>:client_name, \
         :dataset=>proc{Client.filter(:name=>client_name)}, \
         :eager_loader=>(proc do |key_hash, invoices, associations|