sequel 3.31.0 → 3.32.0

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

@@ -6,6 +6,8 @@ module Sequel
     module Derby
       # Instance methods for Derby Database objects accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Asql\d+\z/i.freeze
+
         include ::Sequel::JDBC::Transactions
 
         # Derby doesn't support casting integer to varchar, only integer to char,
@@ -37,6 +39,12 @@ module Sequel
         
         private
         
+        # Derby optimizes away Sequel's default check of SELECT NULL FROM table,
+        # so use a SELECT * FROM table there.
+        def _table_exists?(ds)
+          ds.first
+        end
+    
         # Derby-specific syntax for renaming columns and changing a columns type/nullity.
         def alter_table_sql(table, op)
           case op[:op]
@@ -86,6 +94,11 @@ module Sequel
           "RENAME TABLE #{quote_schema_table(name)} TO #{quote_schema_table(new_name)}"
         end
 
+        # Primary key indexes appear to be named sqlNNNN on Derby
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
+
         # If an :identity option is present in the column, add the necessary IDENTITY SQL.
         def type_literal(column)
           if column[:identity]

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

@@ -75,7 +75,16 @@ module Sequel
           when :set_column_null
             "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET#{' NOT' unless op[:null]} NULL"
           when :set_column_type
-            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+            if sch = schema(table)
+              if cs = sch.each{|k, v| break v if k == op[:name]; nil}
+                cs = cs.dup
+                cs[:default] = cs[:ruby_default]
+                op = cs.merge!(op)
+              end
+            end
+            sql = "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+            column_definition_order.each{|m| send(:"column_definition_#{m}_sql", sql, op)}
+            sql
           else
             super(table, op)
           end

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

@@ -6,6 +6,8 @@ module Sequel
     module HSQLDB
       # Instance methods for HSQLDB Database objects accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Asys_idx_sys_pk_/i.freeze
+
         include ::Sequel::JDBC::Transactions
 
         # HSQLDB uses the :hsqldb database type.
@@ -54,6 +56,11 @@ module Sequel
             rs.getInt(1)
           end
         end
+        
+        # Primary key indexes appear to start with sys_idx_sys_pk_ on HSQLDB
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
 
         # If an :identity option is present in the column, add the necessary IDENTITY SQL.
         # It's possible to use an IDENTITY type, but that defaults the sequence to start

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

@@ -7,6 +7,8 @@ module Sequel
     module Oracle
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Asys_/i.freeze
+
         include Sequel::Oracle::DatabaseMethods
         include Sequel::JDBC::Transactions
 
@@ -39,6 +41,11 @@ module Sequel
           end
         end
 
+        # Primary key indexes appear to start with sys_ on Oracle
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
+
         def schema_parse_table(*)
           sch = super
           sch.each do |c, s|

data/lib/sequel/adapters/mock.rb

@@ -276,6 +276,10 @@ module Sequel
       def disconnect_connection(c)
       end
 
+      def log_connection_execute(c, sql)
+        c.execute(sql)
+      end
+
       def quote_identifiers_default
         false
       end

data/lib/sequel/adapters/mysql.rb

@@ -29,6 +29,9 @@ module Sequel
 
     class << self
       # Whether to convert invalid date time values by default.
+      #
+      # Only applies to Sequel::Database instances created after this
+      # has been set.
       attr_accessor :convert_invalid_date_time
     end
     self.convert_invalid_date_time = false

data/lib/sequel/adapters/oracle.rb

@@ -236,9 +236,13 @@ module Sequel
         pks = ds.select_map(:cols__column_name)
 
         # Default values
-        defaults =  metadata_dataset.from(:dba_tab_cols).
-          where(:table_name=>im.call(table)).
-          to_hash(:column_name, :data_default)
+        defaults = begin
+          metadata_dataset.from(:dba_tab_cols).
+            where(:table_name=>im.call(table)).
+            to_hash(:column_name, :data_default)
+        rescue DatabaseError
+          {}
+        end
 
         metadata = synchronize(opts[:server]) do |conn|
           begin

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

@@ -60,9 +60,16 @@ module Sequel
 
       # Use SYSCAT.INDEXES to get the indexes for the table
       def indexes(table, opts = {})
+        m = output_identifier_meth
+        indexes = {}
         metadata_dataset.
-          with_sql("SELECT INDNAME,UNIQUERULE,MADE_UNIQUE,SYSTEM_REQUIRED FROM SYSCAT.INDEXES WHERE TABNAME = #{literal(input_identifier_meth.call(table))}").
-          all.map{|h| Hash[ h.map{|k,v| [k.to_sym, v]} ] }
+         from(:syscat__indexes).
+         select(:indname, :uniquerule, :colnames).
+         where(:tabname=>input_identifier_meth.call(table), :system_required=>0).
+         each do |r|
+          indexes[m.call(r[:indname])] = {:unique=>(r[:uniquerule]=='U'), :columns=>r[:colnames][1..-1].split('+').map{|v| m.call(v)}}
+        end
+        indexes
       end
 
       private

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

@@ -28,6 +28,26 @@ module Sequel
         :mssql
       end
       
+      # Use the system tables to get index information
+      def indexes(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        indexes = {}
+        metadata_dataset.from(:sys__tables___t).
+         join(:sys__indexes___i, :object_id=>:object_id).
+         join(:sys__index_columns___ic, :object_id=>:object_id, :index_id=>:index_id).
+         join(:sys__columns___c, :object_id=>:object_id, :column_id=>:column_id).
+         select(:i__name, :i__is_unique, :c__name___column).
+         where{{t__name=>im.call(table)}}.
+         where(:i__is_primary_key=>0, :i__is_disabled=>0).
+         order(:i__name, :ic__index_column_id).
+         each do |r|
+          index = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>(r[:is_unique] && r[:is_unique]!=0)}
+          index[:columns] << m.call(r[:column])
+        end
+        indexes
+      end
+
       # The version of the MSSQL server, as an integer (e.g. 10001600 for
       # SQL Server 2008 Express).
       def server_version(server=nil)
@@ -79,7 +99,21 @@ module Sequel
         when :rename_column
           "sp_rename #{literal("#{quote_schema_table(table)}.#{quote_identifier(op[:name])}")}, #{literal(op[:new_name].to_s)}, 'COLUMN'"
         when :set_column_type
-          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+          sqls = []
+          if sch = schema(table)
+            if cs = sch.each{|k, v| break v if k == op[:name]; nil}
+              cs = cs.dup
+              if constraint = default_constraint_name(table, op[:name])
+                sqls << "ALTER TABLE #{quote_schema_table(table)} DROP CONSTRAINT #{constraint}"
+              end
+              cs[:default] = cs[:ruby_default]
+              op = cs.merge!(op)
+              default = op.delete(:default)
+            end
+          end
+          sqls << "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{column_definition_sql(op)}"
+          sqls << alter_table_sql(table, op.merge(:op=>:set_column_default, :default=>default)) if default
+          sqls
         when :set_column_null
           sch = schema(table).find{|k,v| k.to_s == op[:name].to_s}.last
           type = sch[:db_type]
@@ -122,6 +156,18 @@ module Sequel
         "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)} (#{column_list_sql(generator)})"
       end
       
+      # The name of the constraint for setting the default value on the table and column.
+      def default_constraint_name(table, column)
+        from(:sysobjects___c_obj).
+          join(:syscomments___com, :id=>:id).
+          join(:sysobjects___t_obj, :id=>:c_obj__parent_obj).
+          join(:sysconstraints___con, :constid=>:c_obj__id).
+          join(:syscolumns___col, :id=>:t_obj__id, :colid=>:colid).
+          where{{c_obj__uid=>user_id{}}}.
+          where(:c_obj__xtype=>'D', :t_obj__name=>table.to_s, :col__name=>column.to_s).
+          get(:c_obj__name)
+      end
+
       # The SQL to drop an index for the table.
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
@@ -238,7 +284,7 @@ module Sequel
         if index[:type] == :full_text
           "CREATE FULLTEXT INDEX ON #{quote_schema_table(table_name)} #{literal(index[:columns])} KEY INDEX #{literal(index[:key_index])}"
         else
-          "CREATE #{'UNIQUE ' if index[:unique]}#{'CLUSTERED ' if index[:type] == :clustered}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
+          "CREATE #{'UNIQUE ' if index[:unique]}#{'CLUSTERED ' if index[:type] == :clustered}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{" INCLUDE #{literal(index[:include])}" if index[:include]}"
         end
       end
     end

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

@@ -1,5 +1,6 @@
 module Sequel
   Dataset::NON_SQL_OPTIONS << :insert_ignore
+  Dataset::NON_SQL_OPTIONS << :update_ignore
   Dataset::NON_SQL_OPTIONS << :on_duplicate_key_update
 
   module MySQL
@@ -311,13 +312,17 @@ module Sequel
       # MySQL has both datetime and timestamp classes, most people are going
       # to want datetime
       def type_literal_generic_datetime(column)
-        :datetime
+        if column[:default] == Sequel::CURRENT_TIMESTAMP
+          :timestamp
+        else
+          :datetime
+        end
       end
 
       # MySQL has both datetime and timestamp classes, most people are going
       # to want datetime
       def type_literal_generic_time(column)
-        column[:only_time] ? :time : :datetime
+        column[:only_time] ? :time : type_literal_generic_datetime(column)
       end
 
       # MySQL doesn't have a true boolean class, so it uses tinyint(1)
@@ -336,7 +341,7 @@ module Sequel
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from where order limit')
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert ignore into columns values on_duplicate_key_update')
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set where order limit')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update ignore table set where order limit')
       SPACE = Dataset::SPACE
       PAREN_OPEN = Dataset::PAREN_OPEN
       PAREN_CLOSE = Dataset::PAREN_CLOSE
@@ -467,7 +472,7 @@ module Sequel
       def insert_ignore
         clone(:insert_ignore=>true)
       end
-      
+
       # Sets up the insert methods to use ON DUPLICATE KEY UPDATE
       # If you pass no arguments, ALL fields will be
       # updated with the new values.  If you pass the fields you
@@ -549,6 +554,16 @@ module Sequel
         false
       end
       
+      # Sets up the update methods to use UPDATE IGNORE.
+      # Useful if you have a unique key and want to just skip
+      # updating rows that violate the unique key restriction.
+      #
+      #   dataset.update_ignore.update({:name => 'a', :value => 1})
+      #   # UPDATE IGNORE tablename SET name = 'a', value = 1
+      def update_ignore
+        clone(:update_ignore=>true)
+      end
+      
       private
 
       # MySQL supports the ORDER BY and LIMIT clauses for DELETE statements
@@ -591,6 +606,11 @@ module Sequel
         sql << IGNORE if opts[:insert_ignore]
       end
 
+      # MySQL supports UPDATE IGNORE
+      def update_ignore_sql(sql)
+        sql << IGNORE if opts[:update_ignore]
+      end
+
       # If this is an replace instead of an insert, use replace instead
       def insert_insert_sql(sql)
         sql << (@opts[:replace] ? REPLACE : INSERT)

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

@@ -17,7 +17,7 @@ module Sequel
       end
 
       def current_user
-        @current_user ||= get{sys_context('USERENV', 'CURRENT_USER')}
+        @current_user ||= metadata_dataset.get{sys_context('USERENV', 'CURRENT_USER')}
       end
 
       def drop_sequence(name)
@@ -30,17 +30,18 @@ module Sequel
       end
 
       def tables(opts={})
-        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE')
-        ds.map{|r| ds.send(:output_identifier, r[:tname])}
+        m = output_identifier_meth
+        metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE').map{|r| m.call(r[:tname])}
       end
 
       def views(opts={}) 
-        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW') 
-        ds.map{|r| ds.send(:output_identifier, r[:tname])} 
+        m = output_identifier_meth
+        metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW').map{|r| m.call(r[:tname])}
       end 
  
       def view_exists?(name) 
-        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'VIEW').count > 0 
+        m = input_identifier_meth
+        metadata_dataset.from(:tab).filter(:tname =>m.call(name), :tabtype => 'VIEW').count > 0 
       end 
 
       private

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

@@ -9,7 +9,7 @@ module Sequel
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where group order having compounds')
 
       # Progress requires SQL standard datetimes
       def requires_sql_standard_datetimes?

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

@@ -170,6 +170,8 @@ module Sequel
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
       def apply_alter_table(table, ops)
+        fks = foreign_keys
+        self.foreign_keys = false if fks
         transaction do 
           if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint}
             # If you are just doing constraints, apply all of them at the same time,
@@ -181,6 +183,7 @@ module Sequel
             ops.each{|op| alter_table_sql_list(table, [op]).flatten.each{|sql| execute_ddl(sql)}}
           end
         end
+        self.foreign_keys = true if fks
       end
 
       # SQLite supports limited table modification.  You can add a column
@@ -208,7 +211,7 @@ module Sequel
         when :set_column_null
           duplicate_table(table){|columns| columns.each{|s| s[:null] = op[:null] if s[:name].to_s == op[:name].to_s}}
         when :set_column_type
-          duplicate_table(table){|columns| columns.each{|s| s[:type] = op[:type] if s[:name].to_s == op[:name].to_s}}
+          duplicate_table(table){|columns| columns.each{|s| s.merge!(op) if s[:name].to_s == op[:name].to_s}}
         when :drop_constraint
           case op[:type]
           when :primary_key
@@ -238,6 +241,11 @@ module Sequel
         end
       end
 
+      # Surround default with parens to appease SQLite
+      def column_definition_default_sql(sql, column)
+        sql << " DEFAULT (#{literal(column[:default])})" if column.include?(:default)
+      end
+    
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.
       def connection_pragmas
@@ -268,15 +276,13 @@ module Sequel
         end
 
         begin
-          if foreign_keys
-            metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
-              c = cols.find {|co| co[:name] == row[:from] } or next
-              c[:table] = row[:table]
-              c[:key] = row[:to]
-              c[:on_update] = on_delete_sql_to_sym(row[:on_update])
-              c[:on_delete] = on_delete_sql_to_sym(row[:on_delete])
-              # is there any way to get deferrable status?
-            end
+          metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
+            c = cols.find {|co| co[:name] == row[:from] } or next
+            c[:table] = row[:table]
+            c[:key] = row[:to]
+            c[:on_update] = on_delete_sql_to_sym(row[:on_update])
+            c[:on_delete] = on_delete_sql_to_sym(row[:on_delete])
+            # is there any way to get deferrable status?
           end
         rescue Sequel::DatabaseError
           # Doesn't work correctly on some versions of JDBC SQLite,

data/lib/sequel/core.rb

@@ -25,6 +25,7 @@
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
+  @empty_array_handle_nulls = true
   @virtual_row_instance_eval = true
   @require_thread = nil
   
@@ -54,6 +55,27 @@ module Sequel
     # days on +DateTime+).
     attr_accessor :datetime_class
 
+    # Sets whether or not to attempt to handle NULL values correctly when given
+    # an empty array.  By default:
+    #
+    #   DB[:a].filter(:b=>[])
+    #   # SELECT * FROM a WHERE (b != b)
+    #   DB[:a].exclude(:b=>[])
+    #   # SELECT * FROM a WHERE (b = b)
+    #
+    # However, some databases (e.g. MySQL) will perform very poorly
+    # with this type of query.  You can set this to false to get the
+    # following behavior:
+    #
+    #   DB[:a].filter(:b=>[])
+    #   # SELECT * FROM a WHERE 1 = 0
+    #   DB[:a].exclude(:b=>[])
+    #   # SELECT * FROM a WHERE 1 = 1
+    # 
+    # This may not handle NULLs correctly, but can be much faster on
+    # some databases.
+    attr_accessor :empty_array_handle_nulls
+
     # For backwards compatibility, has no effect.
     attr_accessor :virtual_row_instance_eval
     

data/lib/sequel/database/query.rb

@@ -184,16 +184,19 @@ module Sequel
     # to the database.
     #
     #   DB.table_exists?(:foo) # => false
-    #   # SELECT * FROM foo LIMIT 1
+    #   # SELECT NULL FROM foo LIMIT 1
+    #
+    # Note that since this does a SELECT from the table, it can give false negatives
+    # if you don't have permission to SELECT from the table.
     def table_exists?(name)
       sch, table_name = schema_and_table(name)
       name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
-      from(name).first
+      _table_exists?(from(name))
       true
-    rescue
+    rescue DatabaseError
       false
     end
-    
+
     # Return all tables in the database as an array of symbols.
     #
     #   DB.tables # => [:albums, :artists]
@@ -238,6 +241,12 @@ module Sequel
     
     private
     
+    # Should raise an error if the table doesn't not exist,
+    # and not raise an error if the table does exist.
+    def _table_exists?(ds)
+      ds.get(Sequel::NULL)
+    end
+    
     # Internal generic transaction method.  Any exception raised by the given
     # block will cause the transaction to be rolled back.  If the exception is
     # not a Sequel::Rollback, the error will be reraised. If no exception occurs