sequel 3.47.0 → 3.48.0

data/lib/sequel/timezones.rb

@@ -82,7 +82,7 @@ module Sequel
     end
     
     # Convert the given object into an object of <tt>Sequel.datetime_class</tt> in the
-    # +application_timezone+.  Used when coverting datetime/timestamp columns
+    # +application_timezone+.  Used when converting datetime/timestamp columns
     # returned by the database.
     def database_to_application_timestamp(v)
       convert_timestamp(v, Sequel.database_timezone)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 47
+  MINOR = 48
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/lib/sequel_core.rb

@@ -1 +1,2 @@
 require 'sequel/core'
+Sequel::Deprecation.deprecate('require "sequel_core"', 'Switch to require "sequel/core"')

data/lib/sequel_model.rb

@@ -1 +1,2 @@
 require 'sequel/model'
+Sequel::Deprecation.deprecate('require "sequel_model"', 'Switch to require "sequel"')

data/spec/adapters/mssql_spec.rb

@@ -195,78 +195,38 @@ describe "MSSQL Dataset#output" do
   end
 end
 
-describe "MSSQL dataset" do
+describe "MSSQL dataset using #with and #with_recursive" do
   before do
     @db = MSSQL_DB
     @ds = MSSQL_DB[:t]
-  end
-
-  describe "using #with and #with_recursive" do
-    before do
       @ds1 = @ds.with(:t, @db[:x])
       @ds2 = @ds.with_recursive(:t, @db[:x], @db[:t])
-    end
-
-    specify "should prepend UPDATE statements with WITH clause" do
-      @ds1.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X]) UPDATE [T] SET [X] = [Y]'
-      @ds2.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) UPDATE [T] SET [X] = [Y]'
-    end
-
-    specify "should prepend DELETE statements with WITH clause" do
-      @ds1.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X]) DELETE FROM [T] WHERE ([Y] = 1)'
-      @ds2.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) DELETE FROM [T] WHERE ([Y] = 1)'
-    end
+  end
 
-    specify "should prepend INSERT statements with WITH clause" do
-      @ds1.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X]) INSERT INTO [T] SELECT * FROM [T]'
-      @ds2.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) INSERT INTO [T] SELECT * FROM [T]'
-    end
+  specify "should prepend UPDATE statements with WITH clause" do
+    @ds1.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X]) UPDATE [T] SET [X] = [Y]'
+    @ds2.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) UPDATE [T] SET [X] = [Y]'
+  end
 
-    specify "should move WITH clause on joined dataset to top level" do
-      @db[:s].inner_join(@ds1).sql.should == "WITH [T] AS (SELECT * FROM [X]) SELECT * FROM [S] INNER JOIN (SELECT * FROM [T]) AS [T1]"
-      @ds1.inner_join(@db[:s].with(:s, @db[:y])).sql.should == "WITH [T] AS (SELECT * FROM [X]), [S] AS (SELECT * FROM [Y]) SELECT * FROM [T] INNER JOIN (SELECT * FROM [S]) AS [T1]"
-    end
+  specify "should prepend DELETE statements with WITH clause" do
+    @ds1.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X]) DELETE FROM [T] WHERE ([Y] = 1)'
+    @ds2.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) DELETE FROM [T] WHERE ([Y] = 1)'
+  end
 
-    describe "on #import" do
-      before do
-        @db = @db.clone
-        class << @db
-          attr_reader :import_sqls
-
-          def execute(sql, opts={})
-            @import_sqls ||= []
-            @import_sqls << sql
-          end
-          alias execute_dui execute
-
-          def transaction(opts={})
-            @import_sqls ||= []
-            @import_sqls << 'BEGIN'
-            yield
-            @import_sqls << 'COMMIT'
-          end
-        end
-      end
+  specify "should prepend INSERT statements with WITH clause" do
+    @ds1.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X]) INSERT INTO [T] SELECT * FROM [T]'
+    @ds2.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) INSERT INTO [T] SELECT * FROM [T]'
+  end
 
-      specify "should prepend INSERT statements with WITH clause" do
-        @db[:items].with(:items, @db[:inventory].group(:type)).import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
-        @db.import_sqls.should == [
-          'BEGIN',
-          "WITH [ITEMS] AS (SELECT * FROM [INVENTORY] GROUP BY [TYPE]) INSERT INTO [ITEMS] ([X], [Y]) SELECT 1, 2 UNION ALL SELECT 3, 4",
-          'COMMIT',
-          'BEGIN',
-          "WITH [ITEMS] AS (SELECT * FROM [INVENTORY] GROUP BY [TYPE]) INSERT INTO [ITEMS] ([X], [Y]) SELECT 5, 6",
-          'COMMIT'
-        ]
-      end
-    end
+  specify "should move WITH clause on joined dataset to top level" do
+    @db[:s].inner_join(@ds1).sql.should == "WITH [T] AS (SELECT * FROM [X]) SELECT * FROM [S] INNER JOIN (SELECT * FROM [T]) AS [T1]"
+    @ds1.inner_join(@db[:s].with(:s, @db[:y])).sql.should == "WITH [T] AS (SELECT * FROM [X]), [S] AS (SELECT * FROM [Y]) SELECT * FROM [T] INNER JOIN (SELECT * FROM [S]) AS [T1]"
   end
 end
 
 describe "MSSQL::Dataset#import" do
   before do
     @db = MSSQL_DB
-    @db.create_table!(:test){primary_key :x; Integer :y}
     @db.sqls.clear
     @ds = @db[:test]
   end
@@ -275,9 +235,16 @@ describe "MSSQL::Dataset#import" do
   end
   
   specify "#import should work correctly with an arbitrary output value" do
+    @db.create_table!(:test){primary_key :x; Integer :y}
     @ds.output(nil, [:inserted__y, :inserted__x]).import([:y], [[3], [4]]).should == [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
     @ds.all.should == [{:x=>1, :y=>3}, {:x=>2, :y=>4}]
   end
+
+  specify "should handle WITH statements" do
+    @db.create_table!(:test){Integer :x; Integer :y}
+    @db[:testx].with(:testx, @db[:test]).import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+    @ds.select_order_map([:x, :y]).should == [[1, 2], [3, 4], [5, 6]]
+  end
 end
 
 describe "MSSQL joined datasets" do

data/spec/adapters/postgres_spec.rb

@@ -643,25 +643,6 @@ describe "A PostgreSQL database" do
     @db[:posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
   end
     
-  specify "should support resetting the primary key sequence with default_schema" do
-    begin
-      @db.run("DROP SCHEMA p") rescue nil
-      @db.run("CREATE SCHEMA p")
-      @db.default_schema = :p
-      @db.create_table(:posts){primary_key :a}
-      @db[:p__posts].insert(:a=>20).should == 20
-      @db[:p__posts].insert.should == 1
-      @db[:p__posts].insert.should == 2
-      @db[:p__posts].insert(:a=>10).should == 10
-      @db.reset_primary_key_sequence(:posts).should == 21
-      @db[:p__posts].insert.should == 21
-      @db[:p__posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
-    ensure
-      @db.default_schema = nil
-      @db.run("DROP SCHEMA p CASCADE")
-    end
-  end
-
   specify "should support specifying Integer/Bignum/Fixnum types in primary keys and have them be auto incrementing" do
     @db.create_table(:posts){primary_key :a, :type=>Integer}
     @db[:posts].insert.should == 1
@@ -959,15 +940,6 @@ describe "Postgres::Database schema qualified tables" do
     @db.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
   end
 
-  specify "#default_schema= should change the default schema used from public" do
-    @db.create_table(:schema_test__schema_test){primary_key :i}
-    @db.default_schema = :schema_test
-    @db.table_exists?(:schema_test).should == true
-    @db.tables.should == [:schema_test]
-    @db.primary_key(:schema_test__schema_test).should == 'i'
-    @db.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
-  end
-
   specify "should handle schema introspection cases with tables with same name in multiple schemas" do
     begin
       @db.create_table(:schema_test__schema_test) do
@@ -2103,8 +2075,8 @@ describe 'PostgreSQL hstore handling' do
     c.one_to_many :items, :class=>c, :key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer), :key_method=>:item_id
     c.many_to_many :related_items, :class=>c, :join_table=>:items___i, :left_key=>Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer), :right_key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
 
-    c.many_to_one :other_item, :class=>c, :key=>:id, :primary_key_method=>:item_id, :primary_key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
-    c.one_to_many :other_items, :class=>c, :primary_key=>:item_id, :key=>:id, :primary_key_column=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
+    c.many_to_one :other_item, :class=>c, :key=>:id, :primary_key_method=>:item_id, :primary_key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer), :reciprocal=>:other_items
+    c.one_to_many :other_items, :class=>c, :primary_key=>:item_id, :key=>:id, :primary_key_column=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer), :reciprocal=>:other_item
     c.many_to_many :other_related_items, :class=>c, :join_table=>:items___i, :left_key=>:id, :right_key=>:id,
       :left_primary_key_column=>Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer),
       :left_primary_key=>:left_item_id,
@@ -2180,18 +2152,18 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h1['a']).should == 'b'
     @ds.get(h1['d']).should == nil
 
-    @ds.get(h2.concat(h3).keys.pg_array.length).should == 2
-    @ds.get(h1.concat(h3).keys.pg_array.length).should == 3
-    @ds.get(h2.merge(h3).keys.pg_array.length).should == 2
-    @ds.get(h1.merge(h3).keys.pg_array.length).should == 3
+    @ds.get(h2.concat(h3).keys.length).should == 2
+    @ds.get(h1.concat(h3).keys.length).should == 3
+    @ds.get(h2.merge(h3).keys.length).should == 2
+    @ds.get(h1.merge(h3).keys.length).should == 3
 
     unless [:do].include?(@db.adapter_scheme)
       # Broken DataObjects thinks operators with ? represent placeholders
-      @ds.get(h1.contain_all(Sequel.pg_array(%w'a c'))).should == true
-      @ds.get(h1.contain_all(Sequel.pg_array(%w'a d'))).should == false
+      @ds.get(h1.contain_all(%w'a c')).should == true
+      @ds.get(h1.contain_all(%w'a d')).should == false
 
-      @ds.get(h1.contain_any(Sequel.pg_array(%w'a d'))).should == true
-      @ds.get(h1.contain_any(Sequel.pg_array(%w'e d'))).should == false
+      @ds.get(h1.contain_any(%w'a d')).should == true
+      @ds.get(h1.contain_any(%w'e d')).should == false
     end
 
     @ds.get(h1.contains(h2)).should == true
@@ -2205,7 +2177,7 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h1.defined('d')).should == false
 
     @ds.get(h1.delete('a')['c']).should == nil
-    @ds.get(h1.delete(Sequel.pg_array(%w'a d'))['c']).should == nil
+    @ds.get(h1.delete(%w'a d')['c']).should == nil
     @ds.get(h1.delete(h2)['c']).should == nil
 
     @ds.from(Sequel.hstore('a'=>'b', 'c'=>nil).op.each).order(:key).all.should == [{:key=>'a', :value=>'b'}, {:key=>'c', :value=>nil}]
@@ -2223,11 +2195,11 @@ describe 'PostgreSQL hstore handling' do
       @ds.get(h1.exist?('d')).should == false
     end
 
-    @ds.get(h1.hstore.hstore.hstore.keys.pg_array.length).should == 2
-    @ds.get(h1.keys.pg_array.length).should == 2
-    @ds.get(h2.keys.pg_array.length).should == 1
-    @ds.get(h1.akeys.pg_array.length).should == 2
-    @ds.get(h2.akeys.pg_array.length).should == 1
+    @ds.get(h1.hstore.hstore.hstore.keys.length).should == 2
+    @ds.get(h1.keys.length).should == 2
+    @ds.get(h2.keys.length).should == 1
+    @ds.get(h1.akeys.length).should == 2
+    @ds.get(h2.akeys.length).should == 1
 
     @ds.from(Sequel.hstore('t'=>'s').op.populate(Sequel::SQL::Cast.new(nil, :items))).select_map(:t).should == ['s']
     @ds.from(:items___i).select(Sequel.hstore('t'=>'s').op.record_set(:i).as(:r)).from_self(:alias=>:s).select(Sequel.lit('(r).*')).from_self.select_map(:t).should == ['s']
@@ -2235,22 +2207,22 @@ describe 'PostgreSQL hstore handling' do
     @ds.from(Sequel.hstore('t'=>'s', 'a'=>'b').op.skeys.as(:s)).select_order_map(:s).should == %w'a t'
     @ds.from((Sequel.hstore('t'=>'s', 'a'=>'b').op - 'a').skeys.as(:s)).select_order_map(:s).should == %w't'
 
-    @ds.get(h1.slice(Sequel.pg_array(%w'a c')).keys.pg_array.length).should == 2
-    @ds.get(h1.slice(Sequel.pg_array(%w'd c')).keys.pg_array.length).should == 1
-    @ds.get(h1.slice(Sequel.pg_array(%w'd e')).keys.pg_array.length).should == nil
+    @ds.get(h1.slice(%w'a c').keys.length).should == 2
+    @ds.get(h1.slice(%w'd c').keys.length).should == 1
+    @ds.get(h1.slice(%w'd e').keys.length).should == nil
 
     @ds.from(Sequel.hstore('t'=>'s', 'a'=>'b').op.svals.as(:s)).select_order_map(:s).should == %w'b s'
 
-    @ds.get(h1.to_array.pg_array.length).should == 4
-    @ds.get(h2.to_array.pg_array.length).should == 2
+    @ds.get(h1.to_array.length).should == 4
+    @ds.get(h2.to_array.length).should == 2
 
-    @ds.get(h1.to_matrix.pg_array.length).should == 2
-    @ds.get(h2.to_matrix.pg_array.length).should == 1
+    @ds.get(h1.to_matrix.length).should == 2
+    @ds.get(h2.to_matrix.length).should == 1
 
-    @ds.get(h1.values.pg_array.length).should == 2
-    @ds.get(h2.values.pg_array.length).should == 1
-    @ds.get(h1.avals.pg_array.length).should == 2
-    @ds.get(h2.avals.pg_array.length).should == 1
+    @ds.get(h1.values.length).should == 2
+    @ds.get(h2.values.length).should == 1
+    @ds.get(h1.avals.length).should == 2
+    @ds.get(h2.avals.length).should == 1
   end
 end if POSTGRES_DB.type_supported?(:hstore)
 

data/spec/adapters/spec_helper.rb

@@ -20,7 +20,7 @@ if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel::Dataset.introspect_all_columns
 end
 
-Sequel::Model.cache_anonymous_models = false
+Sequel.cache_anonymous_models = false
 
 class Sequel::Database
   def log_duration(duration, message)

data/spec/adapters/sqlite_spec.rb

@@ -317,7 +317,7 @@ describe "An SQLite dataset AS clause" do
   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'"
+    SQLITE_DB[:t].join_table(:natural, :j, nil, :table_alias=>:a).sql.should == "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
   end
 end
 

data/spec/bin_spec.rb

@@ -0,0 +1,251 @@
+require 'rubygems'
+require 'rbconfig'
+require 'yaml'
+
+RUBY = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['RUBY_INSTALL_NAME'])
+OUTPUT = "spec/bin-sequel-spec-output-#{$$}.log"
+TMP_FILE = "spec/bin-sequel-tmp-#{$$}.rb"
+BIN_SPEC_DB = "spec/bin-sequel-spec-db-#{$$}.sqlite3"
+BIN_SPEC_DB2 = "spec/bin-sequel-spec-db2-#{$$}.sqlite3"
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+  CONN_PREFIX = 'jdbc:sqlite:'
+  CONN_HASH = {:adapter=>'jdbc', :uri=>"#{CONN_PREFIX}#{BIN_SPEC_DB}"}
+else
+  CONN_PREFIX = 'sqlite://'
+  CONN_HASH = {:adapter=>'sqlite', :database=>BIN_SPEC_DB}
+end
+
+unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
+  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+  require 'sequel'
+end
+
+DB = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB}")
+DB2 = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB2}")
+File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
+File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
+
+describe "bin/sequel" do
+  def bin(opts={})
+    cmd = "#{opts[:pre]}\"#{RUBY}\" -I lib bin/sequel #{opts[:args]} #{"#{CONN_PREFIX}#{BIN_SPEC_DB}" unless opts[:no_conn]} #{opts[:post]}> #{OUTPUT}#{" 2>&1" if opts[:stderr]}"
+    system(cmd)
+    File.read(OUTPUT)
+  end
+
+  after do
+    DB.disconnect
+    DB2.disconnect
+    File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
+    File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
+    File.delete(TMP_FILE) if File.file?(TMP_FILE)
+  end
+  after(:all) do
+    File.delete(OUTPUT) if File.file?(OUTPUT)
+  end
+  
+  it "-h should print the help" do
+    help = bin(:args=>"-h", :no_conn=>true)
+    help.should =~ /\ASequel: The Database Toolkit for Ruby/
+    help.should =~ /^Usage: sequel /
+  end
+
+  it "-c should run code" do
+    bin(:args=>'-c "print DB.tables.inspect"').should == '[]'
+    DB.create_table(:a){Integer :a}
+    bin(:args=>'-c "print DB.tables.inspect"').should == '[:a]'
+  end
+
+  it "-C should copy databases" do
+    DB.create_table(:a) do
+      primary_key :a
+      String :name
+    end
+    DB.create_table(:b) do
+      foreign_key :a, :a
+      index :a
+    end
+    DB[:a].insert(1, 'foo')
+    DB[:b].insert(1)
+    bin(:args=>'-C', :post=>"#{CONN_PREFIX}#{BIN_SPEC_DB2}").should =~ Regexp.new(<<END)
+Databases connections successful
+Migrations dumped successfully
+Tables created
+Begin copying data
+Begin copying records for table: a
+Finished copying 1 records for table: a
+Begin copying records for table: b
+Finished copying 1 records for table: b
+Finished copying data
+Begin creating indexes
+Finished creating indexes
+Begin adding foreign key constraints
+Finished adding foreign key constraints
+Database copy finished in \\d\\.\\d+ seconds
+END
+    DB2.tables.sort_by{|t| t.to_s}.should == [:a, :b]
+    DB[:a].all.should == [{:a=>1, :name=>'foo'}]
+    DB[:b].all.should == [{:a=>1}]
+    DB2.schema(:a).should == [[:a, {:allow_null=>false, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}], [:name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}]]
+    DB2.schema(:b).should == [[:a, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}]]
+    DB2.indexes(:a).should == {}
+    DB2.indexes(:b).should == {:b_a_index=>{:unique=>false, :columns=>[:a]}}
+    DB2.foreign_key_list(:a).should == []
+    DB2.foreign_key_list(:b).should == [{:columns=>[:a], :table=>:a, :key=>nil, :on_update=>:no_action, :on_delete=>:no_action}]
+  end
+
+  it "-d and -D should dump generic and specific migrations" do
+    DB.create_table(:a) do
+      primary_key :a
+      String :name
+    end
+    DB.create_table(:b) do
+      foreign_key :a, :a
+      index :a
+    end
+    bin(:args=>'-d').should == <<END
+Sequel.migration do
+  change do
+    create_table(:a) do
+      primary_key :a
+      String :name, :size=>255
+    end
+    
+    create_table(:b, :ignore_index_errors=>true) do
+      foreign_key :a, :a
+      
+      index [:a]
+    end
+  end
+end
+END
+    bin(:args=>'-D').should == <<END
+Sequel.migration do
+  change do
+    create_table(:a) do
+      primary_key :a
+      column :name, "varchar(255)"
+    end
+    
+    create_table(:b) do
+      foreign_key :a, :a
+      
+      index [:a]
+    end
+  end
+end
+END
+  end
+
+  it "-E should echo SQL statements to stdout" do
+    bin(:args=>'-E -c DB.tables').should =~ %r{I, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA foreign_keys = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA case_sensitive_like = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
+  end
+
+  it "-I should include directory in load path" do
+    bin(:args=>'-Ifoo -c "p 1 if $:.include?(\'foo\')"').should == "1\n"
+  end
+
+  it "-l should log SQL statements to file" do
+    bin(:args=>"-l #{TMP_FILE} -c DB.tables").should == ''
+    File.read(TMP_FILE).should =~ %r{I, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA foreign_keys = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA case_sensitive_like = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
+  end
+
+  it "-L should load all *.rb files in given directory" do
+    bin(:args=>'-L ./lib/sequel/connection_pool -c "p [Sequel::SingleConnectionPool, Sequel::ThreadedConnectionPool, Sequel::ShardedSingleConnectionPool, Sequel::ShardedThreadedConnectionPool].length"').should == "4\n"
+  end
+
+  it "-m should migrate database up" do
+    bin(:args=>"-m spec/files/integer_migrations").should == ''
+    DB.tables.sort_by{|t| t.to_s}.should == [:schema_info, :sm1111, :sm2222, :sm3333]
+  end
+
+  it "-M should specify version to migrate to" do
+    bin(:args=>"-m spec/files/integer_migrations -M 2").should == ''
+    DB.tables.sort_by{|t| t.to_s}.should == [:schema_info, :sm1111, :sm2222]
+  end
+
+  it "-N should not test for a valid connection" do
+    bin(:no_conn=>true, :args=>"-c '' -N #{CONN_PREFIX}spec/nonexistent/foo").should == ''
+    bin(:no_conn=>true, :args=>"-c '' #{CONN_PREFIX}spec/nonexistent/foo", :stderr=>true).should =~ /\AError: Sequel::DatabaseConnectionError: /
+  end
+
+  it "-r should require a given library" do
+    bin(:args=>'-rsequel/extensions/sql_expr -c "print DB.literal(1.sql_expr)"').should == "1"
+  end
+
+  it "-S should dump the schema cache" do
+    bin(:args=>"-S #{TMP_FILE}").should == ''
+    Marshal.load(File.read(TMP_FILE)).should == {}
+    DB.create_table(:a){Integer :a}
+    bin(:args=>"-S #{TMP_FILE}").should == ''
+    Marshal.load(File.read(TMP_FILE)).should == {"`a`"=>[[:a, {:type=>:integer, :db_type=>"integer", :ruby_default=>nil, :allow_null=>true, :default=>nil, :primary_key=>false}]]}
+  end
+
+  it "-t should output full backtraces on error" do
+    bin(:args=>'-c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").should < 3
+    bin(:args=>'-t -c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").should > 3
+  end
+
+  it "-v should output the Sequel version" do
+    bin(:args=>"-v", :no_conn=>true).should == "sequel #{Sequel.version}\n"
+  end
+
+  it "should error if using -M without -m" do
+    bin(:args=>'-M 2', :stderr=>true).should == "Error: Must specify -m if using -M\n"
+  end
+
+  it "should error if using mutually exclusive options together" do
+    bin(:args=>'-c foo -d', :stderr=>true).should == "Error: Cannot specify -c and -d together\n"
+    bin(:args=>'-D -d', :stderr=>true).should == "Error: Cannot specify -D and -d together\n"
+    bin(:args=>'-m foo -d', :stderr=>true).should == "Error: Cannot specify -m and -d together\n"
+    bin(:args=>'-S foo -d', :stderr=>true).should == "Error: Cannot specify -S and -d together\n"
+  end
+
+  it "should use a mock database if no database is given" do
+    bin(:args=>'-c "print DB.adapter_scheme"', :no_conn=>true).should == "mock"
+  end
+
+  it "should work with a yaml config file" do
+    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(CONN_HASH))}
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[]"
+    DB.create_table(:a){Integer :a}
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+  end
+
+  it "should work with a yaml config file with string keys" do
+    h = {}
+    CONN_HASH.each{|k,v| h[k.to_s] = v}
+    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(h))}
+    DB.create_table(:a){Integer :a}
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+  end
+
+  it "should work with a yaml config file with environments" do
+    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(:development=>CONN_HASH))}
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[]"
+    DB.create_table(:a){Integer :a}
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+  end
+
+  it "-e should set environment for yaml config file" do
+    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(:foo=>CONN_HASH))}
+    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[]"
+    DB.create_table(:a){Integer :a}
+    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump('foo'=>CONN_HASH))}
+    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+  end
+
+  it "should run code in given filenames" do
+    File.open(TMP_FILE, 'wb'){|f| f.write('print DB.tables.inspect')}
+    bin(:post=>TMP_FILE).should == '[]'
+    DB.create_table(:a){Integer :a}
+    bin(:post=>TMP_FILE).should == '[:a]'
+  end
+
+  it "should run code provided on stdin" do
+    bin(:pre=>'echo print DB.tables.inspect | ').should == '[]'
+    DB.create_table(:a){Integer :a}
+    bin(:pre=>'echo print DB.tables.inspect | ').should == '[:a]'
+  end
+end