colincasey-sequel 2.10.0 → 2.10.1

data/spec/integration/prepared_statement_test.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Prepared Statements and Bound Arguments" do
+  before do
+    INTEGRATION_DB.create_table!(:items) do
+      primary_key :id
+      integer :number
+    end
+    @c = Class.new(Sequel::Model(:items))
+    @ds = INTEGRATION_DB[:items]
+    @ds.insert(:number=>10)
+    @ds.meta_def(:ba) do |sym|
+      prepared_arg_placeholder == '$' ? :"#{sym}__int" : sym
+    end
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items)
+  end
+  
+  specify "should support bound variables with select, all, and first" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).call(:all, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).call(:first, :n=>10).should == {:id=>1, :number=>10}
+  end
+
+  specify "should support placeholder literal strings" do
+    @ds.filter("number = ?", @ds.ba(:$n)).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support datasets with static sql and placeholders" do
+    INTEGRATION_DB["SELECT * FROM items WHERE number = ?", @ds.ba(:$n)].call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects" do
+    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>@ds.ba(:$n))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects with literal strings" do
+    @ds.filter(:id=>:$i, :number=>@ds.select(:number).filter("number = ?", @ds.ba(:$n))).call(:select, :n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects with static sql and placeholders" do
+    @ds.filter(:id=>:$i, :number=>INTEGRATION_DB["SELECT number FROM items WHERE number = ?", @ds.ba(:$n)]).call(:select, :n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support subselects of subselects" do
+    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>@ds.select(:number).filter(:number=>@ds.ba(:$n)))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should support bound variables with insert" do
+    @ds.call(:insert, {:n=>20, :i=>100}, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+
+  specify "should have insert return primary key value when using bound arguments" do
+    @ds.call(:insert, {:n=>20}, :number=>@ds.ba(:$n)).should == 2
+    @ds.filter(:id=>2).first[:number].should == 20
+  end
+
+  specify "should support bound variables with delete" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:delete, :n=>10).should == 1
+    @ds.count.should == 0
+  end
+
+  specify "should support bound variables with update" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:update, {:n=>10, :nn=>20}, :number=>:number+@ds.ba(:$nn)).should == 1
+    @ds.all.should == [{:id=>1, :number=>30}]
+  end
+  
+  specify "should support prepared statements with select, first, and all" do
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:select, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:all, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == {:id=>1, :number=>10}
+    if INTEGRATION_DB.uri =~ /jdbc:sqlite:/
+      # Work around for open prepared statements on a table not allowing the
+      # dropping of a table when using SQLite over JDBC
+      INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}
+    end
+  end
+
+  specify "should support prepared statements with insert" do
+    @ds.prepare(:insert, :insert_n, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
+    INTEGRATION_DB.call(:insert_n, :n=>20, :i=>100)
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+
+  specify "should have insert return primary key value when using prepared statements" do
+    @ds.prepare(:insert, :insert_n, :number=>@ds.ba(:$n))
+    INTEGRATION_DB.call(:insert_n, :n=>20).should == 2
+    @ds.filter(:id=>2).first[:number].should == 20
+  end
+
+  specify "should support prepared statements with delete" do
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:delete, :delete_n)
+    INTEGRATION_DB.call(:delete_n, :n=>10).should == 1
+    @ds.count.should == 0
+  end
+
+  specify "should support prepared statements with update" do
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:update, :update_n, :number=>:number+@ds.ba(:$nn))
+    INTEGRATION_DB.call(:update_n, :n=>10, :nn=>20).should == 1
+    @ds.all.should == [{:id=>1, :number=>30}]
+  end
+  
+  specify "model datasets should return model instances when using select, all, and first with bound variables" do
+    @c.filter(:number=>@ds.ba(:$n)).call(:select, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).call(:all, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).call(:first, :n=>10).should == @c.load(:id=>1, :number=>10)
+  end
+  
+  specify "model datasets should return model instances when using select, all, and first with prepared statements" do
+    @c.filter(:number=>@ds.ba(:$n)).prepare(:select, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).prepare(:all, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == @c.load(:id=>1, :number=>10)
+    if INTEGRATION_DB.uri =~ /jdbc:sqlite:/
+      # Work around for open prepared statements on a table not allowing the
+      # dropping of a table when using SQLite over JDBC
+      INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}
+    end
+  end
+end

data/spec/integration/schema_test.rb

@@ -0,0 +1,180 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+if INTEGRATION_DB.respond_to?(:schema_parse_table, true)
+describe "Database schema parser" do
+  before do
+    @iom = INTEGRATION_DB.identifier_output_method
+    @iim = INTEGRATION_DB.identifier_input_method
+    @defsch = INTEGRATION_DB.default_schema
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    INTEGRATION_DB.identifier_output_method = @iom
+    INTEGRATION_DB.identifier_input_method = @iim
+    INTEGRATION_DB.default_schema = @defsch
+  end
+
+  specify "should handle a database with a identifier_output_method" do
+    INTEGRATION_DB.identifier_output_method = :reverse
+    INTEGRATION_DB.identifier_input_method = :reverse
+    INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(nil, :reload=>true)[:items].should be_a_kind_of(Array)
+    INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
+  end
+
+  specify "should be a hash with table_names as symbols" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    schema = INTEGRATION_DB.schema(nil, :reload=>true)
+    schema.should be_a_kind_of(Hash)
+    schema[:items].should_not == nil
+  end
+
+  specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(nil, :reload=>true)
+    clear_sqls
+    INTEGRATION_DB.schema
+    sqls_should_be
+  end
+
+  specify "should give the same result for a single table regardless of whether schema was called for a single table" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items]
+  end
+
+  specify "should raise an error when the table doesn't exist" do
+    proc{INTEGRATION_DB.schema(:no_table)}.should raise_error(Sequel::Error)
+  end
+
+  specify "should return the schema correctly" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    schema = INTEGRATION_DB.schema(:items, :reload=>true)
+    schema.should be_a_kind_of(Array)
+    schema.length.should == 1
+    col = schema.first
+    col.should be_a_kind_of(Array)
+    col.length.should == 2
+    col.first.should == :number
+    col_info = col.last
+    col_info.should be_a_kind_of(Hash)
+    col_info[:type].should == :integer
+    clear_sqls
+    INTEGRATION_DB.schema(:items)
+    sqls_should_be
+  end
+
+  specify "should parse primary keys from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    INTEGRATION_DB.create_table!(:items){primary_key :number}
+    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    INTEGRATION_DB.create_table!(:items){integer :number1; integer :number2; primary_key [:number1, :number2]}
+    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+  end
+
+  specify "should parse NULL/NOT NULL from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){integer :number, :null=>true}
+    INTEGRATION_DB.schema(:items).first.last[:allow_null].should == true
+    INTEGRATION_DB.create_table!(:items){integer :number, :null=>false}
+    INTEGRATION_DB.schema(:items).first.last[:allow_null].should == false
+  end
+
+  specify "should parse defaults from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(:items).first.last[:default].should == nil
+    INTEGRATION_DB.create_table!(:items){integer :number, :default=>0}
+    INTEGRATION_DB.schema(:items).first.last[:default].to_s.should == "0"
+    INTEGRATION_DB.create_table!(:items){varchar :a, :default=>"blah", :size=>4}
+    INTEGRATION_DB.schema(:items).first.last[:default].gsub(/::character varying\z/, '').gsub("'", '').should == "blah"
+  end
+end
+end
+
+describe "Database schema modifiers" do
+  before do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    @ds = INTEGRATION_DB[:items]
+    @ds.insert([10])
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+  end
+
+  specify "should create tables correctly" do
+    INTEGRATION_DB.table_exists?(:items).should == true
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @ds.columns!.should == [:number]
+  end
+
+  specify "should add columns to tables correctly" do
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @ds.columns!.should == [:number]
+    INTEGRATION_DB.alter_table(:items){add_column :name, :text}
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
+    @ds.columns!.should == [:number, :name]
+    unless INTEGRATION_DB.url =~ /sqlite/
+      INTEGRATION_DB.alter_table(:items){add_primary_key :id}
+      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id]
+      @ds.columns!.should == [:number, :name, :id]
+      INTEGRATION_DB.alter_table(:items){add_foreign_key :item_id, :items}
+      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
+      @ds.columns!.should == [:number, :name, :id, :item_id]
+    end
+  end
+
+  specify "should remove columns from tables correctly" do
+    INTEGRATION_DB.create_table!(:items) do
+      primary_key :id
+      text :name
+      integer :number
+      foreign_key :item_id, :items
+    end
+    @ds.insert(:number=>10)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number, :item_id]
+    @ds.columns!.should == [:id, :name, :number, :item_id]
+    INTEGRATION_DB.drop_column(:items, :number)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :item_id]
+    @ds.columns!.should == [:id, :name, :item_id]
+    INTEGRATION_DB.drop_column(:items, :name)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    INTEGRATION_DB.drop_column(:items, :item_id)
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @ds.columns!.should == [:id]
+  end
+end
+
+if INTEGRATION_DB.respond_to?(:tables)
+describe "Database#tables" do
+  before do
+    class ::String
+      @@xxxxx = 0
+      def xxxxx
+        "xxxxx#{@@xxxxx += 1}"
+      end
+    end
+    @iom = INTEGRATION_DB.identifier_output_method
+    @iim = INTEGRATION_DB.identifier_input_method
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.identifier_output_method = @iom
+    INTEGRATION_DB.identifier_input_method = @iim
+  end
+
+  specify "should return an array of symbols" do
+    ts = INTEGRATION_DB.tables
+    ts.should be_a_kind_of(Array)
+    ts.each{|t| t.should be_a_kind_of(Symbol)}
+  end
+
+  specify "should respect the database's identifier_output_method" do
+    INTEGRATION_DB.identifier_output_method = :xxxxx
+    INTEGRATION_DB.identifier_input_method = :xxxxx
+    INTEGRATION_DB.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+  end
+end
+end

data/spec/integration/spec_helper.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel'
+end
+begin
+  require File.join(File.dirname(__FILE__), '../spec_config.rb')
+rescue LoadError
+end
+
+$sqls = []
+def clear_sqls
+  $sqls.clear
+end 
+
+class Spec::Example::ExampleGroup
+  def start_logging
+    require 'logger'
+    INTEGRATION_DB.loggers << Logger.new(STDOUT)
+  end
+  def stop_logging
+     INTEGRATION_DB.loggers.clear
+  end
+end
+
+if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRATION_URL']
+  unless defined?(INTEGRATION_DB)
+    url = defined?(INTEGRATION_URL) ? INTEGRATION_URL : ENV['SEQUEL_INTEGRATION_URL']
+    INTEGRATION_DB = Sequel.connect(url)
+    #INTEGRATION_DB.instance_variable_set(:@server_version, 80100)
+  end
+  class Spec::Example::ExampleGroup
+    def sqls_should_be(*args)
+    end 
+  end
+else
+  sql_logger = Object.new
+  def sql_logger.info(str)
+    $sqls << str 
+  end
+  INTEGRATION_DB = Sequel.sqlite('', :loggers=>[sql_logger], :quote_identifiers=>false)
+  class Spec::Example::ExampleGroup
+    def sqls_should_be(*sqls)
+      sqls.zip($sqls).each do |should_be, is|
+        case should_be
+        when String
+          is.should == should_be
+        when Regexp
+          is.should =~ should_be
+        else
+          raise ArgumentError, "need String or RegExp"
+        end
+      end
+      $sqls.length.should == sqls.length
+      clear_sqls
+    end 
+  end
+end

data/spec/integration/type_test.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Supported types" do
+  def create_items_table_with_column(name, type, opts={})
+    INTEGRATION_DB.create_table!(:items){column name, type, opts}
+    INTEGRATION_DB[:items]
+  end
+
+  specify "should support casting correctly" do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => 1)
+    ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
+    ds = create_items_table_with_column(:name, String)
+    ds.insert(:name=> '1')
+    ds.select(:name.cast_numeric.as(:n)).map(:n).should == [1]
+  end
+
+  specify "should support NULL correctly" do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => nil)
+    ds.all.should == [{:number=>nil}]
+  end
+
+  specify "should support generic integer type" do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => 2)
+    ds.all.should == [{:number=>2}]
+  end
+  
+  specify "should support generic fixnum type" do
+    ds = create_items_table_with_column(:number, Fixnum)
+    ds.insert(:number => 2)
+    ds.all.should == [{:number=>2}]
+  end
+  
+  specify "should support generic bignum type" do
+    ds = create_items_table_with_column(:number, Bignum)
+    ds.insert(:number => 2**34)
+    ds.all.should == [{:number=>2**34}]
+  end
+  
+  specify "should support generic float type" do
+    ds = create_items_table_with_column(:number, Float)
+    ds.insert(:number => 2.1)
+    ds.all.should == [{:number=>2.1}]
+  end
+  
+  specify "should support generic numeric type" do
+    ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
+    ds.insert(:number => BigDecimal.new('2.123456789'))
+    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+    ds = create_items_table_with_column(:number, BigDecimal, :size=>[15, 10])
+    ds.insert(:number => BigDecimal.new('2.123456789'))
+    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+  end
+
+  specify "should support generic string type" do
+    ds = create_items_table_with_column(:name, String)
+    ds.insert(:name => 'Test User')
+    ds.all.should == [{:name=>'Test User'}]
+  end
+  
+  specify "should support generic date type" do
+    ds = create_items_table_with_column(:dat, Date)
+    d = Date.today
+    ds.insert(:dat => d)
+    ds.first[:dat].should == d
+  end
+  
+  specify "should support generic datetime type" do
+    ds = create_items_table_with_column(:tim, DateTime)
+    t = DateTime.now
+    ds.insert(:tim => t)
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+    ds = create_items_table_with_column(:tim, Time)
+    t = Time.now
+    ds.insert(:tim => t)
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+  end
+  
+  specify "should support generic file type" do
+    ds = create_items_table_with_column(:name, File)
+    ds.insert(:name => ("a\0"*300).to_sequel_blob)
+    ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]
+    ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
+  end
+  
+  specify "should support generic boolean type" do
+    ds = create_items_table_with_column(:number, TrueClass)
+    ds.insert(:number => true)
+    ds.all.should == [{:number=>true}]
+    ds = create_items_table_with_column(:number, FalseClass)
+    ds.insert(:number => true)
+    ds.all.should == [{:number=>true}]
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude
+gems
+--exclude
+spec
+--exclude
+00*