sequel 3.1.0 → 3.2.0

data/doc/virtual_rows.rdoc

@@ -1,65 +1,56 @@
 = Virtual Row Blocks
 
-Dataset methods filter, order, and select all take blocks that yield
-instances of Sequel::SQL::VirtualRow.  These are referred to as
+Dataset methods filter, order, and select all take blocks that either yield
+instances of Sequel::SQL::VirtualRow (if the block takes an argument), or
+are evaluated in the context of an instance of Sequel::SQL::VirtualRow.  These are referred to as
 virtual row blocks.  Many other dataset methods pass the blocks
 they are given into one of those three methods, so there are actually
 many Sequel methods that take virtual row blocks.
 
 VirtualRow is a class that returns SQL::Indentifiers,
-SQL::QualifiedIdentifiers, or SQL::Functions depending on how it is
+SQL::QualifiedIdentifiers, SQL::Functions, or SQL::WindowFunctions depending on how it is
 called.  This is best shown by example:
 
   ds = DB[:items]
-  ds.filter{|o| o.column > 1}        # column > 1
-  ds.filter{|o| o.table__column > 1} # table.column > 1
-  ds.filter{|o| o.function(1) > 1}   # function(1) > 1
-  
-Basically, the rules are:
-
-* If there are arguments, an SQL::Function is returned with the
-  name of the method used and the arguments given.
-
-* If there are no arguments and the method contains a double
-  underscore, split on the double underscore and return an
-  SQL::QualifiedIdentifier with the table and column.
-  
-* Otherwise, create an SQL::Identifier with the name of the
-  method.
-  
-One of the consequences of these rules is that you cannot
-create an SQL::Function that takes no arguments using a VirtualRow
-instance.
-  
-In Sequel 2.12, the following is deprecated by default, as
-virtual row blocks are required to accept an argument:
-
-  ds.filter{:column > 1}                     # column > 1
-  ds.filter{:table__column > 1}              # table.column > 1
-  ds.filter{:function.sql_function(1) > 1}   # function(1) > 1
-  
-This is to keep backwards compatibility while notifying people
-to change their code.  In Sequel 3.0, you will be able to
-do:
-
   ds.filter{column > 1}        # column > 1
   ds.filter{table__column > 1} # table.column > 1
   ds.filter{function(1) > 1}   # function(1) > 1
+  ds.select{version{}}   # version()
+  ds.select{count(:*){}} # count(*)
+  ds.select{count(:distinct, col1){}} # count(DISTINCT col1)
+  ds.select{rank(:over){}} # rank() OVER ()
+  ds.select{count(:over, :*=>true){}} # count(*) OVER ()
+  ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}} # sum(col1) OVER (PARTITION BY col2 ORDER BY col3)
+  
+Basically, the rules are:
 
-Sequel 3.0 will change the virtual row block support to use
-instance_eval if the block doesn't take an argument.  This
-breaks backward compatibility because instance methods called
-inside the block will now have a virtual row instance as a
-receiver instead of the receiver where the block was defined.
-You can still use local variables in the enclosing scope
-inside the block, as they take on their usual meaning.
-
-If you find yourself needing to call instance methods for the
-current receiver inside a virtual row block, you should change
-the block to accept an argument, and use that argument whenever
-you need the virtual row support.
-
-You can get the Sequel 3.0 behavior in Sequel 2.12 using the
-following method:
-
-  Sequel.virtual_row_instance_eval = true
+* If a block is given:
+  * The block is currently not called.  This may change in a future version.
+  * If there are no arguments, an SQL::Function with the name of
+    method used, and no arguments.
+  * If the first argument is :*, an SQL::Function is created with a single
+    wildcard argument (*).
+  * If the first argument is :distinct, an SQL::Function is created with
+    the keyword DISTINCT prefacing all remaining arguments.
+  * If the first argument is :over, the second argument if provided should
+    be a hash of options to pass to SQL::Window.  The options hash can also
+    contain :*=>true to use a wildcard argument as the function argument, or
+    :args=>... to specify an array of arguments to use as the function arguments.
+* If a block is not given:
+  * If there are arguments, an SQL::Function is returned with the
+    name of the method used and the arguments given.
+  * If there are no arguments and the method contains a double
+    underscore, split on the double underscore and return an
+    SQL::QualifiedIdentifier with the table and column.
+  * Otherwise, create an SQL::Identifier with the name of the
+    method.
+  
+If you use a virtual row block that doesn't take an argument,
+the block is instance_evaled, so you can't reference methods
+in the enclosing scope.  If you need to call methods of the
+enclosing scope, you should assign the results to local variables
+before the block, or just make the block take an argument and use
+that.  If you want to create identifiers or qualified identifiers
+with the same name as existing local variables, make sure ruby
+knows it is a method call instead of a local variable reference
+by not ommiting the parentheses at the end of the method call.

data/lib/sequel/adapters/ado.rb

@@ -1,4 +1,3 @@
-Sequel.require 'adapters/utils/date_format'
 require 'win32ole'
 
 module Sequel
@@ -28,9 +27,9 @@ module Sequel
       # Connect to the database. In addition to the usual database options,
       # the following option has effect:
       #
-      # * :command_timout - Sets the time in seconds to wait while attempting
+      # * :command_timeout - Sets the time in seconds to wait while attempting
       #     to execute a command before cancelling the attempt and generating
-      #     an error. Specificially, it sets the ADO CommandTimeout property.
+      #     an error. Specifically, it sets the ADO CommandTimeout property.
       #     If this property is not set, the default of 30 seconds is used.
       # * :provider - Sets the Provider of this ADO connection (for example, "SQLOLEDB")
 
@@ -66,8 +65,6 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      include Dataset::SQLStandardDateFormat
-
       def fetch_rows(sql)
         execute(sql) do |s|
           @columns = s.Fields.extend(Enumerable).map do |column|

data/lib/sequel/adapters/db2.rb

@@ -90,6 +90,11 @@ module Sequel
         self
       end
       
+      # DB2 supports window functions
+      def supports_window_functions?
+        true
+      end
+      
       private
 
       def get_column_info(sth)

data/lib/sequel/adapters/do.rb

@@ -130,6 +130,7 @@ module Sequel
       # to do a transaction.  So we close the connection created and
       # substitute our own.
       def begin_transaction(conn)
+        return super if supports_savepoints?
         log_info(TRANSACTION_BEGIN)
         t = ::DataObjects::Transaction.create_for_uri(uri)
         t.instance_variable_get(:@connection).close
@@ -141,6 +142,7 @@ module Sequel
       # DataObjects requires transactions be prepared before being
       # committed, so we do that.
       def commit_transaction(t)
+        return super if supports_savepoints?
         log_info(TRANSACTION_ROLLBACK)
         t.prepare
         t.commit 
@@ -170,6 +172,7 @@ module Sequel
       
       # We use the transactions rollback method to rollback.
       def rollback_transaction(t)
+        return super if supports_savepoints?
         log_info(TRANSACTION_COMMIT)
         t.rollback
       end

data/lib/sequel/adapters/firebird.rb

@@ -1,5 +1,4 @@
 require 'fb'
-Sequel.require 'adapters/utils/unsupported'
 
 module Sequel
   # The Sequel Firebird adapter requires the ruby fb driver located at
@@ -199,14 +198,12 @@ module Sequel
 
     # Dataset class for Firebird datasets
     class Dataset < Sequel::Dataset
-      include UnsupportedIntersectExcept
-
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       NULL = LiteralString.new('NULL').freeze
       COMMA_SEPARATOR = ', '.freeze
       FIREBIRD_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
-      SELECT_CLAUSE_ORDER = %w'distinct limit columns from join where group having compounds order'.freeze
+      SELECT_CLAUSE_ORDER = %w'with distinct limit columns from join where group having compounds order'.freeze
 
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -262,6 +259,11 @@ module Sequel
         sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
       end
 
+      # Firebird does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+
       private
 
       def hash_row(stmt, row)

data/lib/sequel/adapters/informix.rb

@@ -1,4 +1,3 @@
-Sequel.require 'adapters/utils/unsupported'
 require 'informix'
 
 module Sequel
@@ -38,8 +37,6 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      include UnsupportedIntersectExcept
-
       SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group compounds order'.freeze
 
       def fetch_rows(sql, &block)
@@ -64,6 +61,11 @@ module Sequel
 
       private
 
+      # Informix does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+
       def select_clause_order
         SELECT_CLAUSE_ORDER
       end

data/lib/sequel/adapters/jdbc.rb

@@ -134,7 +134,9 @@ module Sequel
       
       # Connect to the database using JavaSQL::DriverManager.getConnection.
       def connect(server)
-        setup_connection(JavaSQL::DriverManager.getConnection(uri(server_opts(server))))
+        args = [uri(server_opts(server))]
+        args.concat([opts[:user], opts[:password]]) if opts[:user] && opts[:password]
+        setup_connection(JavaSQL::DriverManager.getConnection(*args))
       end
       
       # Return instances of JDBC::Dataset with the given opts.
@@ -223,7 +225,7 @@ module Sequel
       
       # JDBC uses a statement object to execute SQL on the database
       def begin_transaction(conn)
-        conn = conn.createStatement
+        conn = conn.createStatement unless supports_savepoints?
         super
       end
       
@@ -304,7 +306,7 @@ module Sequel
       
       # Close the given statement when removing the transaction
       def remove_transaction(stmt)
-        stmt.close if stmt
+        stmt.close if stmt && !supports_savepoints?
         super
       end
       
@@ -464,14 +466,14 @@ module Sequel
       def process_result_set(result)
         # get column names
         meta = result.getMetaData
-        column_count = meta.getColumnCount
-        @columns = []
-        column_count.times{|i| @columns << output_identifier(meta.getColumnLabel(i+1))}
-
+        cols = []
+        i = 0
+        meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
+        @columns = cols.map{|c| c.at(0)}
         # get rows
         while result.next
           row = {}
-          @columns.each_with_index{|v, i| row[v] = convert_type(result.getObject(i+1))}
+          cols.each{|n, i| row[n] = convert_type(result.getObject(i))}
           yield row
         end
       end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -1,5 +1,3 @@
-Sequel.require %w'date_format unsupported', 'adapters/utils'
-
 module Sequel
   module JDBC
     # Database and Dataset support for H2 databases accessed via JDBC.
@@ -65,8 +63,23 @@ module Sequel
       
       # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        include Dataset::SQLStandardDateFormat
-        include Dataset::UnsupportedIsTrue
+        SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+        
+        # H2 requires SQL standard datetimes
+        def requires_sql_standard_datetimes?
+          true
+        end
+
+        # H2 doesn't support IS TRUE
+        def supports_is_true?
+          false
+        end
+        
+        private
+      
+        def select_clause_order
+          SELECT_CLAUSE_ORDER
+        end
       end
     end
   end

data/lib/sequel/adapters/mysql.rb

@@ -16,7 +16,8 @@ module Sequel
     # Use only a single proc for each type to save on memory
     MYSQL_TYPE_PROCS = {
       [0, 246]  => lambda{|v| BigDecimal.new(v)},                       # decimal
-      [1, 2, 3, 8, 9, 13, 247, 248]  => lambda{|v| v.to_i},             # integer
+      [1]  => lambda{|v| Sequel.convert_tinyint_to_bool ? v.to_i != 0 : v.to_i}, # tinyint
+      [2, 3, 8, 9, 13, 247, 248]  => lambda{|v| v.to_i},                # integer
       [4, 5]  => lambda{|v| v.to_f},                                    # float
       [10, 14]  => lambda{|v| convert_date_time(:string_to_date, v)},   # date
       [7, 12] => lambda{|v| convert_date_time(:string_to_datetime, v)}, # datetime
@@ -295,11 +296,12 @@ module Sequel
       # Yield all rows matching this dataset
       def fetch_rows(sql)
         execute(sql) do |r|
-          column_types = []
-          @columns = r.fetch_fields.map{|f| column_types << f.type; output_identifier(f.name)}
+          i = -1
+          cols = r.fetch_fields.map{|f| [output_identifier(f.name), MYSQL_TYPES[f.type], i+=1]}
+          @columns = cols.map{|c| c.first}
           while row = r.fetch_row
             h = {}
-            @columns.each_with_index {|f, i| h[f] = convert_type(row[i], column_types[i])}
+            cols.each{|n, p, i| v = row[i]; h[n] = (v && p) ? p.call(v) : v}
             yield h
           end
         end
@@ -335,21 +337,6 @@ module Sequel
       
       private
       
-      # Convert the type of v using the method in MYSQL_TYPES[type].
-      def convert_type(v, type)
-        if v
-          if type == 1 && Sequel.convert_tinyint_to_bool
-            # We special case tinyint here to avoid adding
-            # a method to an ancestor of Fixnum
-            v.to_i == 0 ? false : true
-          else
-            (b = MYSQL_TYPES[type]) ? b.call(v) : v
-          end
-        else
-          nil
-        end
-      end
-      
       # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts={}, &block)
         super(sql, {:type=>:select}.merge(opts), &block)

data/lib/sequel/adapters/odbc.rb

@@ -44,16 +44,16 @@ module Sequel
         ODBC::Dataset.new(self, opts)
       end
     
-      # ODBC returns native statement objects, which must be dropped if
-      # you call execute manually, or you will get warnings.  See the
-      # fetch_rows method source code for an example of how to drop
-      # the statements.
       def execute(sql, opts={})
         log_info(sql)
         synchronize(opts[:server]) do |conn|
-          r = conn.run(sql)
-          yield(r) if block_given?
-          r
+          begin
+            r = conn.run(sql)
+            yield(r) if block_given?
+          ensure
+            r.drop if r
+          end
+          nil
         end
       end
       
@@ -85,19 +85,15 @@ module Sequel
 
       def fetch_rows(sql, &block)
         execute(sql) do |s|
-          begin
-            untitled_count = 0
-            @columns = s.columns(true).map do |c|
-              if (n = c.name).empty?
-                n = UNTITLED_COLUMN % (untitled_count += 1)
-              end
-              output_identifier(n)
+          untitled_count = 0
+          @columns = s.columns(true).map do |c|
+            if (n = c.name).empty?
+              n = UNTITLED_COLUMN % (untitled_count += 1)
             end
-            rows = s.fetch_all
-            rows.each {|row| yield hash_row(row)} if rows
-          ensure
-            s.drop unless s.nil? rescue nil
+            output_identifier(n)
           end
+          rows = s.fetch_all
+          rows.each {|row| yield hash_row(row)} if rows
         end
         self
       end

data/lib/sequel/adapters/openbase.rb

@@ -37,6 +37,8 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+      
       def fetch_rows(sql)
         execute(sql) do |result|
           begin
@@ -52,6 +54,12 @@ module Sequel
         end
         self
       end
+      
+      private
+      
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
     end
   end
 end

data/lib/sequel/adapters/shared/mssql.rb

@@ -1,5 +1,3 @@
-Sequel.require 'adapters/utils/unsupported'
-
 module Sequel
   module MSSQL
     module DatabaseMethods
@@ -48,9 +46,7 @@ module Sequel
     end
   
     module DatasetMethods
-      include Dataset::UnsupportedIntersectExcept
-
-      SELECT_CLAUSE_ORDER = %w'limit distinct columns from with join where group order having compounds'.freeze
+      SELECT_CLAUSE_ORDER = %w'with limit distinct columns from table_options join where group order having compounds'.freeze
 
       def complex_expression_sql(op, args)
         case op
@@ -72,13 +68,23 @@ module Sequel
 
       # Allows you to do .nolock on a query
       def nolock
-        clone(:with => "(NOLOCK)")
+        clone(:table_options => "(NOLOCK)")
       end
 
       def quoted_identifier(name)
         "[#{name}]"
       end
 
+      # Microsoft SQL Server does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+      
+      # MSSQL 2005+ supports window functions
+      def supports_window_functions?
+        true
+      end
+
       private
 
       def literal_string(v)
@@ -96,8 +102,8 @@ module Sequel
       end
 
       # MSSQL uses the WITH statement to lock tables
-      def select_with_sql(sql)
-        sql << " WITH #{@opts[:with]}" if @opts[:with]
+      def select_table_options_sql(sql)
+        sql << " WITH #{@opts[:table_options]}" if @opts[:table_options]
       end
     end
   end