sequel 3.27.0 → 3.28.0

data/lib/sequel/model/base.rb

@@ -23,7 +23,7 @@ module Sequel
       # stored so when the dataset changes, methods defined with def_dataset_method
       # will be applied to the new dataset.
       attr_reader :dataset_methods
-      #
+
       # Array of plugin modules loaded by this class
       #
       #   Sequel::Model.plugins
@@ -423,10 +423,12 @@ module Sequel
         @allowed_columns = cols
       end
   
-      # Sets the dataset associated with the Model class. +ds+ can be a +Symbol+
-      # (specifying a table name in the current database), or a +Dataset+.
+      # Sets the dataset associated with the Model class. +ds+ can be a +Symbol+,
+      # +LiteralString+, <tt>SQL::Identifier</tt>, <tt>SQL::QualifiedIdentifier</tt>,
+      # <tt>SQL::AliasedExpression</tt>
+      # (all specifying a table name in the current database), or a +Dataset+.
       # If a dataset is used, the model's database is changed to the database of the given
-      # dataset.  If a symbol is used, a dataset is created from the current
+      # dataset.  If a dataset is not used, a dataset is created from the current
       # database with the table name given. Other arguments raise an +Error+.
       # Returns self.
       #
@@ -441,15 +443,15 @@ module Sequel
       def set_dataset(ds, opts={})
         inherited = opts[:inherited]
         @dataset = case ds
-        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
           @simple_table = db.literal(ds)
-          db[ds]
+          db.from(ds)
         when Dataset
           @simple_table = nil
           @db = ds.db
           ds
         else
-          raise(Error, "Model.set_dataset takes one of the following classes as an argument: Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, Dataset")
+          raise(Error, "Model.set_dataset takes one of the following classes as an argument: Symbol, LiteralString, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, Dataset")
         end
         @dataset.row_proc = Proc.new{|r| load(r)}
         @require_modification = Sequel::Model.require_modification.nil? ? @dataset.provides_accurate_rows_matched? : Sequel::Model.require_modification
@@ -1684,15 +1686,7 @@ module Sequel
       #   Artist.dataset.with_pk([1, 2]) # SELECT * FROM artists
       #                                  # WHERE ((id1 = 1) AND (id2 = 2)) LIMIT 1
       def with_pk(pk)
-        case primary_key = model.primary_key
-        when Array
-          raise(Error, "single primary key given (#{pk.inspect}) when a composite primary key is expected (#{primary_key.inspect})") unless pk.is_a?(Array)
-          raise(Error, "composite primary key given (#{pk.inspect}) does not match composite primary key length (#{primary_key.inspect})") if pk.length != primary_key.length
-          first(primary_key.zip(pk))
-        else
-          raise(Error, "composite primary key given (#{pk.inspect}) when a single primary key is expected (#{primary_key.inspect})") if pk.is_a?(Array)
-          first(primary_key=>pk)
-        end
+        first(model.qualified_primary_key_hash(pk))
       end
     end
 

data/lib/sequel/plugins/many_through_many.rb

@@ -58,6 +58,19 @@ module Sequel
           self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
 
+        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
+        def eager_loading_predicate_key
+          self[:eager_loading_predicate_key] ||= begin
+            calculate_edges
+            e = self[:edges].first
+            if self[:uses_left_composite_keys]
+              e[:right].map{|k| SQL::QualifiedIdentifier.new(e[:table], k)}
+            else
+              SQL::QualifiedIdentifier.new(e[:table], e[:right])
+            end
+          end
+        end
+    
         # The list of joins to use when eager graphing
         def edges
           self[:edges] || calculate_edges || self[:edges]
@@ -182,13 +195,28 @@ module Sequel
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:eager_loader] ||= lambda do |eo|
             h = eo[:key_hash][left_pk]
-            eo[:rows].each{|object| object.associations[name] = []}
+            rows = eo[:rows]
+            rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
             ft = opts[:final_reverse_edge]
             conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
             ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
-            model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
+            ds = model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo)
+            case opts.eager_limit_strategy
+            when :window_function
+              delete_rn = true
+              rn = ds.row_number_column
+              ds = apply_window_function_eager_limit_strategy(ds, opts)
+            when :correlated_subquery
+              ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
+                dsa = ds.send(:dataset_alias, 2)
+                opts.reverse_edges.each{|t| xds = xds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+                xds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + left_keys.map{|k| [k, SQL::QualifiedIdentifier.new(ft[:table], k)]}, :table_alias=>dsa)
+              end
+            end
+            ds.all do |assoc_record|
+              assoc_record.values.delete(rn) if delete_rn
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
@@ -197,6 +225,10 @@ module Sequel
               next unless objects = h[hash_key]
               objects.each{|object| object.associations[name].push(assoc_record)}
             end
+            if opts.eager_limit_strategy == :ruby
+              limit, offset = opts.limit_and_offset
+              rows.each{|o| o.associations[name] = o.associations[name].slice(offset||0, limit) || []}
+            end
           end
 
           join_type = opts[:graph_join_type]

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -31,7 +31,7 @@ module Sequel
         # Return a prepared statement that can be used to lookup a row given a dataset for the row matching
         # the primary key.
         def prepared_lookup_dataset(ds)
-          @prepared_statements[:lookup_sql][ds.sql] ||= prepare_statement(ds.filter(prepared_statement_key_array(primary_key)), :first)
+          @prepared_statements[:lookup_sql][ds.sql] ||= prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)
         end
       end
 

data/lib/sequel/sql.rb

@@ -41,6 +41,11 @@ module Sequel
   # Time subclass that gets literalized with only the time value, so it operates
   # like a standard SQL time type.
   class SQLTime < ::Time
+    # Create a new SQLTime instance given an hour, minute, and second.
+    def self.create(hour, minute, second, usec = 0)
+      t = now
+      local(t.year, t.month, t.day, hour, minute, second, usec)
+    end
   end
 
   # The SQL module holds classes whose instances represent SQL fragments.
@@ -149,14 +154,17 @@ module Sequel
       # Operator symbols that take exactly two arguments
       TWO_ARITY_OPERATORS = [:'=', :'!=', :LIKE, :'NOT LIKE', \
         :~, :'!~', :'~*', :'!~*', :ILIKE, :'NOT ILIKE'] + \
-        INEQUALITY_OPERATORS + BITWISE_OPERATORS + IS_OPERATORS + IN_OPERATORS
+        INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS
 
       # Operator symbols that take one or more arguments
-      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
+      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS
 
       # Operator symbols that take only a single argument
       ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
 
+      # Custom expressions that may have different syntax on different databases
+      CUSTOM_EXPRESSIONS = [:extract]
+
       # An array of args for this object
       attr_reader :args
 
@@ -185,6 +193,8 @@ module Sequel
           args[1] = orig_args[1] if IN_OPERATORS.include?(op)
         when *ONE_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
+        when *CUSTOM_EXPRESSIONS
+          # nothing
         else
           raise(Error, "Invalid operator #{op}")
         end
@@ -224,14 +234,7 @@ module Sequel
     #   ~:a.sql_number # ~"a"
     module BitwiseMethods
       ComplexExpression::BITWISE_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
-          else  
-            NumericExpression.new(o, self, ce)
-          end
-        end
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
       end
 
       # Do the bitwise compliment of the self
@@ -249,16 +252,24 @@ module Sequel
     #   :a & :b # "a" AND "b"
     #   :a | :b # "a" OR "b"
     #   ~:a # NOT "a"
+    #
+    # One exception to this is when a NumericExpression or Integer is the argument
+    # to & or |, in which case a bitwise method will be used:
+    #
+    #   :a & 1 # "a" & 1 
+    #   :a | (:b + 1) # "a" | ("b" + 1)
     module BooleanMethods
       ComplexExpression::BOOLEAN_OPERATOR_METHODS.each do |m, o|
-        define_method(m) do |ce|
-          case ce
-          when NumericExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression")
-          else  
-            BooleanExpression.new(o, self, ce)
+        module_eval(<<-END, __FILE__, __LINE__+1)
+          def #{m}(o)
+            case o
+            when NumericExpression, Integer
+              NumericExpression.new(#{m.inspect}, self, o)
+            else  
+              BooleanExpression.new(#{o.inspect}, self, o)
+            end
           end
-        end
+        END
       end
       
       # Create a new BooleanExpression with NOT, representing the inversion of whatever self represents.
@@ -326,7 +337,7 @@ module Sequel
       # doesn't use the standard function calling convention, and it
       # doesn't work on all databases.
       def extract(datetime_part)
-        Function.new(:extract, PlaceholderLiteralString.new("#{datetime_part} FROM ?", [self])).sql_number
+        NumericExpression.new(:extract, datetime_part, self)
       end
 
       # Return a BooleanExpression representation of +self+.
@@ -372,34 +383,12 @@ module Sequel
     #   'a'.lit <= :b # a <= "b"
     module InequalityMethods
       ComplexExpression::INEQUALITY_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, ::Array
-            raise(Error, "cannot apply #{o} to a boolean expression")
-          else  
-            BooleanExpression.new(o, self, ce)
-          end
-        end
+        module_eval("def #{o}(o) BooleanExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
       end
     end
 
-    # This module augments the default initalize method for the 
-    # +ComplexExpression+ subclass it is included in, so that
-    # attempting to use boolean input when initializing a +NumericExpression+
-    # or +StringExpression+ results in an error.  It is not expected to be
-    # used directly.
+    # Only exists for backwards compatibility, ignore it.
     module NoBooleanInputMethods
-      # Raise an +Error+ if one of the args would be boolean in an SQL
-      # context, otherwise call super.
-      def initialize(op, *args)
-        args.each do |a|
-          case a
-          when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, ::Array
-            raise(Error, "cannot apply #{op} to a boolean expression")
-          end
-        end
-        super
-      end
     end
 
     # This module includes the standard mathematical methods (+, -, *, and /)
@@ -410,15 +399,26 @@ module Sequel
     #   :a - :b # "a" - "b"
     #   :a * :b # "a" * "b"
     #   :a / :b # "a" / "b"
+    #
+    # One exception to this is if + is called with a +String+ or +StringExpression+,
+    # in which case the || operator is used instead of the + operator:
+    #
+    #   :a + 'b' # "a" || 'b'
     module NumericMethods
       ComplexExpression::MATHEMATICAL_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
-          else  
-            NumericExpression.new(o, self, ce)
-          end
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__) unless o == :+
+      end
+
+      # Use || as the operator when called with StringExpression and String instances,
+      # and the + operator for LiteralStrings and all other types.
+      def +(ce)
+        case ce
+        when LiteralString
+          NumericExpression.new(:+, self, ce)
+        when StringExpression, String
+          StringExpression.new(:'||', self, ce)
+        else
+          NumericExpression.new(:+, self, ce)
         end
       end
     end
@@ -606,6 +606,21 @@ module Sequel
           BooleanExpression.new(:NOT, ce)
         end
       end
+
+      # Always use an AND operator for & on BooleanExpressions
+      def &(ce)
+        BooleanExpression.new(:AND, self, ce)
+      end
+
+      # Always use an OR operator for | on BooleanExpressions
+      def |(ce)
+        BooleanExpression.new(:OR, self, ce)
+      end
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_boolean
+        self
+      end
     end
 
     # Represents an SQL CASE expression, used for conditional branching in SQL.
@@ -673,6 +688,21 @@ module Sequel
       include CastMethods
       include OrderMethods
       include SubscriptMethods
+
+      # Return a BooleanExpression with the same op and args.
+      def sql_boolean
+        BooleanExpression.new(self.op, *self.args)
+      end
+
+      # Return a NumericExpression with the same op and args.
+      def sql_number
+        NumericExpression.new(self.op, *self.args)
+      end
+
+      # Return a StringExpression with the same op and args.
+      def sql_string
+        StringExpression.new(self.op, *self.args)
+      end
     end
 
     # Represents constants or psuedo-constants (e.g. +CURRENT_DATE+) in SQL.
@@ -847,7 +877,16 @@ module Sequel
       include BitwiseMethods 
       include NumericMethods
       include InequalityMethods
-      include NoBooleanInputMethods
+
+      # Always use + for + operator for NumericExpressions.
+      def +(ce)
+        NumericExpression.new(:+, self, ce)
+      end
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_number
+        self
+      end
     end
 
     # Represents a column/expression to order the result set by.
@@ -913,7 +952,6 @@ module Sequel
       include StringMethods
       include StringConcatenationMethods
       include InequalityMethods
-      include NoBooleanInputMethods
 
       # Map of [regexp, case_insenstive] to +ComplexExpression+ operator symbol
       LIKE_MAP = {[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE}
@@ -962,6 +1000,11 @@ module Sequel
         end
       end
       private_class_method :like_element
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_string
+        self
+      end
     end
 
     # Represents an SQL array access, with multiple possible arguments.

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 = 27
+  MINOR = 28
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/db2_spec.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#Author: Roy L Zuo (roylzuo at gmail dot com)
+#Description: 
+
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+require ENV['SEQUEL_DB2_SPEC_REQUIRE'] if ENV['SEQUEL_DB2_SPEC_REQUIRE']
+
+unless defined?(DB2_DB)
+  DB2_DB = Sequel.connect(ENV['SEQUEL_DB2_SPEC_DB']||DB2_URL)
+end
+
+if DB2_DB.table_exists?(:test)
+  DB2_DB.drop_table :test
+end
+INTEGRATION_DB = DB2_DB unless defined?(INTEGRATION_DB)
+
+describe Sequel::Database do
+  before do
+    @db = DB2_DB
+    @db.create_table(:test){String :a}
+    @ds = @db[:test]
+  end
+
+  after do
+    @db.drop_table(:test)
+  end
+  
+  specify "should provide disconnect functionality after preparing a connection" do
+    @ds.prepare(:first, :a).call
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+
+  specify "should return version correctly" do
+    @db.db2_version.should match(/DB2 v/i)
+  end
+end
+
+describe "Simple Dataset operations" do
+  before do
+    DB2_DB.create_table!(:items) do
+      Integer :id, :primary_key => true
+      Integer :number
+    end
+    @ds = DB2_DB[:items]
+    @ds.insert(:number=>10, :id => 1 )
+  end
+  after do
+    DB2_DB.drop_table(:items)
+  end
+  cspecify "should insert with a primary key specified", :mssql do
+    @ds.insert(:id=>100, :number=>20)
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+end
+
+describe Sequel::Database do
+  before do
+    @db = DB2_DB
+  end
+  after do
+    @db.drop_table(:items)
+  end
+  specify "should parse primary keys from the schema properly" do
+    @db.create_table!(:items){Integer :number}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    @db.create_table!(:items){primary_key :number}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+  end
+end
+
+describe "Sequel::IBMDB.convert_smallint_to_bool" do
+  before do
+    @db = DB2_DB
+    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
+    @ds = @db[:booltest]
+  end
+  after do
+    Sequel::IBMDB.convert_smallint_to_bool = true
+    @db.drop_table(:booltest)
+  end
+  
+  specify "should consider smallint datatypes as boolean if set, but not larger smallints" do
+    @db.schema(:booltest, :reload=>true).first.last[:type].should == :boolean
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @db.schema(:booltest, :reload=>true).first.last[:type].should == :integer
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+  end
+  
+  specify "should return smallints as bools and integers as integers when set" do
+    Sequel::IBMDB.convert_smallint_to_bool = true
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.should == [{:b=>true, :i=>10}]
+    @ds.delete
+    @ds << {:b=>false, :i=>0}
+    @ds.all.should == [{:b=>false, :i=>0}]
+    @ds.delete
+    @ds << {:b=>true, :i=>1}
+    @ds.all.should == [{:b=>true, :i=>1}]
+  end
+
+  specify "should return all smallints as integers when unset" do
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds << {:b=>false, :i=>0}
+    @ds.all.should == [{:b=>0, :i=>0}]
+    
+    @ds.delete
+    @ds << {:b=>1, :i=>10}
+    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds << {:b=>0, :i=>0}
+    @ds.all.should == [{:b=>0, :i=>0}]
+  end
+end if DB2_DB.adapter_scheme == :ibmdb
+
+describe "Simple Dataset operations in transactions" do
+  before do
+    DB2_DB.create_table!(:items_insert_in_transaction) do
+      Integer :id, :primary_key => true
+      integer :number
+    end
+    @ds = DB2_DB[:items_insert_in_transaction]
+  end
+  after do
+    DB2_DB.drop_table(:items_insert_in_transaction)
+  end
+
+  specify "should insert correctly with a primary key specified inside a transaction" do
+    DB2_DB.transaction do
+      @ds.insert(:id=>100, :number=>20)
+      @ds.count.should == 1
+      @ds.order(:id).all.should == [{:id=>100, :number=>20}]
+    end
+  end
+end