sequel 3.21.0 → 3.31.0

data/lib/sequel/sql.rb

@@ -38,6 +38,16 @@ module Sequel
   class LiteralString < ::String
   end
 
+  # 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.
   # It also holds modules that are included in core ruby classes that
   # make Sequel a friendly DSL.
@@ -69,7 +79,8 @@ module Sequel
       # the method provided on the dataset with args as the argument (self by default).
       # Used to DRY up some code.
       def self.to_s_method(meth, args=:self) # :nodoc:
-        class_eval("def to_s(ds); ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+        class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+        class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)
       end
       private_class_method :to_s_method
 
@@ -144,14 +155,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
 
@@ -180,6 +194,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
@@ -219,14 +235,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
@@ -244,16 +253,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.
@@ -321,7 +338,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+.
@@ -367,34 +384,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 /)
@@ -405,15 +400,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
@@ -595,10 +601,27 @@ module Sequel
           end
         when StringExpression, NumericExpression
           raise(Sequel::Error, "cannot invert #{ce.inspect}")
+        when Constant
+          CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
         else
           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.
@@ -666,6 +689,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.
@@ -706,6 +744,12 @@ module Sequel
       NOTNULL = NegativeBooleanConstant.new(nil)
     end
 
+    class ComplexExpression
+      # A hash of the opposite for each constant, used for inverting constants.
+      CONSTANT_INVERSIONS = {Constants::TRUE=>Constants::FALSE, Constants::FALSE=>Constants::TRUE,
+                             Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}
+    end
+
     # Represents an SQL function call.
     class Function < GenericExpression
       # The array of arguments to pass to the function (may be blank)
@@ -834,7 +878,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.
@@ -900,7 +953,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}
@@ -949,6 +1001,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/timezones.rb

@@ -39,6 +39,48 @@ module Sequel
       convert_output_timestamp(v, Sequel.database_timezone)
     end
 
+    # Converts the object to the given +output_timezone+.
+    def convert_output_timestamp(v, output_timezone)
+      if output_timezone
+        if v.is_a?(DateTime)
+          case output_timezone
+          when :utc
+            v.new_offset(0)
+          when :local
+            v.new_offset(local_offset_for_datetime(v))
+          else
+            convert_output_datetime_other(v, output_timezone)
+          end
+        else
+          v.send(output_timezone == :utc ? :getutc : :getlocal)
+        end
+      else
+        v
+      end
+    end
+    
+    # Converts the given object from the given input timezone to the
+    # +application_timezone+ using +convert_input_timestamp+ and
+    # +convert_output_timestamp+.
+    def convert_timestamp(v, input_timezone)
+      begin
+        if v.is_a?(Date) && !v.is_a?(DateTime)
+          # Dates handled specially as they are assumed to already be in the application_timezone
+          if datetime_class == DateTime
+            DateTime.civil(v.year, v.month, v.day, 0, 0, 0, application_timezone == :local ? (defined?(Rational) ? Rational(Time.local(v.year, v.month, v.day).utc_offset, 86400) : Time.local(v.year, v.month, v.day).utc_offset/86400.0) : 0)
+          else
+            Time.send(application_timezone == :utc ? :utc : :local, v.year, v.month, v.day)
+          end
+        else
+          convert_output_timestamp(convert_input_timestamp(v, input_timezone), application_timezone)
+        end
+      rescue InvalidValue
+        raise
+      rescue => e
+        raise convert_exception_class(e, InvalidValue)
+      end
+    end
+    
     # Convert the given object into an object of <tt>Sequel.datetime_class</tt> in the
     # +application_timezone+.  Used when coverting datetime/timestamp columns
     # returned by the database.
@@ -103,12 +145,24 @@ module Sequel
           v2
         end
       when Array
-        y, mo, d, h, mi, s = v
+        y, mo, d, h, mi, s, ns, off = v
         if datetime_class == DateTime
-          convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s, 0), input_timezone)
+          s += (defined?(Rational) ? Rational(ns, 1000000000) : ns/1000000000.0) if ns
+          if off
+            DateTime.civil(y, mo, d, h, mi, s, off)
+          else
+            convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s), input_timezone)
+          end
         else
-          Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s)
+          Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+        end
+      when Hash
+        ary = [:year, :month, :day, :hour, :minute, :second, :nanos].map{|x| (v[x] || v[x.to_s]).to_i}
+        if (offset = (v[:offset] || v['offset']))
+          ary << offset
         end
+        convert_input_timestamp(ary, input_timezone)
+        convert_input_timestamp(ary, input_timezone)
       when Time
         if datetime_class == DateTime
           v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)
@@ -121,8 +175,6 @@ module Sequel
         else
           v.respond_to?(:to_time) ? v.to_time : string_to_datetime(v.to_s)
         end
-      when Date
-        convert_input_timestamp(v.to_s, input_timezone)
       else
         raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"
       end
@@ -135,39 +187,6 @@ module Sequel
       raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
     end
     
-    # Converts the object to the given +output_timezone+.
-    def convert_output_timestamp(v, output_timezone)
-      if output_timezone
-        if v.is_a?(DateTime)
-          case output_timezone
-          when :utc
-            v.new_offset(0)
-          when :local
-            v.new_offset(local_offset_for_datetime(v))
-          else
-            convert_output_datetime_other(v, output_timezone)
-          end
-        else
-          v.send(output_timezone == :utc ? :getutc : :getlocal)
-        end
-      else
-        v
-      end
-    end
-    
-    # Converts the given object from the given input timezone to the
-    # +application_timezone+ using +convert_input_timestamp+ and
-    # +convert_output_timestamp+.
-    def convert_timestamp(v, input_timezone)
-      begin
-        convert_output_timestamp(convert_input_timestamp(v, input_timezone), Sequel.application_timezone)
-      rescue InvalidValue
-        raise
-      rescue => e
-        raise convert_exception_class(e, InvalidValue)
-      end
-    end
-    
     # Convert the timezone setter argument.  Returns argument given by default,
     # exists for easier overriding in extensions.
     def convert_timezone_setter_arg(tz)

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 = 21
+  MINOR = 31
   # 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