sequel 5.7.1 → 5.8.0

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

@@ -342,6 +342,7 @@ module Sequel
         /conflicted with the CHECK constraint/ => CheckConstraintViolation,
         /column does not allow nulls/ => NotNullConstraintViolation,
         /was deadlocked on lock resources with another process and has been chosen as the deadlock victim/ => SerializationFailure,
+        /Lock request time out period exceeded\./ => DatabaseLockTimeout,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -712,6 +713,11 @@ module Sequel
         false
       end
       
+      # MSSQL supports NOWAIT.
+      def supports_nowait?
+        true
+      end
+
       # MSSQL 2012+ supports offsets in correlated subqueries.
       def supports_offsets_in_correlated_subqueries?
         is_2012_or_later?
@@ -958,6 +964,7 @@ module Sequel
       def select_lock_sql(sql)
         lock = @opts[:lock]
         skip_locked = @opts[:skip_locked]
+        nowait = @opts[:nowait]
         for_update = lock == :update
         dirty = lock == :dirty
         lock_hint = for_update || dirty
@@ -966,19 +973,12 @@ module Sequel
           sql << " WITH ("
 
           if lock_hint
-            sql << if for_update
-              'UPDLOCK'
-            else
-              'NOLOCK'
-            end
-          end
-
-          if lock_hint && skip_locked
-            sql << ', '
+            sql << (for_update ? 'UPDLOCK' : 'NOLOCK')
           end
 
-          if skip_locked
-            sql << "READPAST"
+          if skip_locked || nowait
+            sql << ', ' if lock_hint
+            sql << (skip_locked ? "READPAST" : "NOWAIT")
           end
 
           sql << ')'

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

@@ -58,6 +58,7 @@ module Sequel
           where(:TABLE_NAME=>im.call(table), :TABLE_SCHEMA=>Sequel.function(:DATABASE)).
           exclude(:CONSTRAINT_NAME=>'PRIMARY').
           exclude(:REFERENCED_TABLE_NAME=>nil).
+          order(:CONSTRAINT_NAME, :POSITION_IN_UNIQUE_CONSTRAINT).
           select(Sequel[:CONSTRAINT_NAME].as(:name), Sequel[:COLUMN_NAME].as(:column), Sequel[:REFERENCED_TABLE_NAME].as(:table), Sequel[:REFERENCED_COLUMN_NAME].as(:key))
         
         h = {}
@@ -407,6 +408,7 @@ module Sequel
         /cannot be null/ => NotNullConstraintViolation,
         /Deadlock found when trying to get lock; try restarting transaction/ => SerializationFailure,
         /CONSTRAINT .+ failed for/ => CheckConstraintViolation,
+        /\AStatement aborted because lock\(s\) could not be acquired immediately and NOWAIT is set\./ => DatabaseLockTimeout,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -561,10 +563,10 @@ module Sequel
       MATCH_AGAINST = ["MATCH ".freeze, " AGAINST (".freeze, ")".freeze].freeze
       MATCH_AGAINST_BOOLEAN = ["MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE)".freeze].freeze
 
-      Dataset.def_sql_method(self, :delete, %w'delete from where order limit')
+      Dataset.def_sql_method(self, :delete, %w'with delete from where order limit')
       Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
       Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having compounds order limit lock')
-      Dataset.def_sql_method(self, :update, %w'update ignore table set where order limit')
+      Dataset.def_sql_method(self, :update, %w'with update ignore table set where order limit')
 
       include Sequel::Dataset::Replace
       include UnmodifiedIdentifiers::DatasetMethods
@@ -579,6 +581,12 @@ module Sequel
             super
           end
         when :~, :'!~', :'~*', :'!~*', :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
+          if !db.mariadb? && db.server_version >= 80000 && [:~, :'!~'].include?(op)
+            func = Sequel.function(:REGEXP_LIKE, args[0], args[1], 'c')
+            func = ~func if op == :'!~'
+            return literal_append(sql, func)
+          end
+
           sql << '('
           literal_append(sql, args[0])
           sql << ' '
@@ -651,7 +659,7 @@ module Sequel
         # Load the PrettyTable class, needed for explain output
         Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
 
-        ds = db.send(:metadata_dataset).with_sql((opts[:extended] ? 'EXPLAIN EXTENDED ' : 'EXPLAIN ') + select_sql).naked
+        ds = db.send(:metadata_dataset).with_sql(((opts[:extended] && (db.mariadb? || db.server_version < 50700)) ? 'EXPLAIN EXTENDED ' : 'EXPLAIN ') + select_sql).naked
         rows = ds.all
         Sequel::PrettyTable.string(rows, ds.columns)
       end
@@ -731,8 +739,16 @@ module Sequel
         sql << '`' << c.to_s.gsub('`', '``') << '`'
       end
 
+      # MariaDB 10.2+ and MySQL 8+ support CTEs
       def supports_cte?(type=:select)
-        type == :select && db.mariadb? && db.server_version >= 100200
+        if db.mariadb?
+          type == :select && db.server_version >= 100200
+        else
+          case type
+          when :select, :update, :delete
+            db.server_version >= 80000
+          end
+        end
       end
 
       # MySQL does not support derived column lists
@@ -766,6 +782,11 @@ module Sequel
         true
       end
 
+      # MySQL 8+ supports NOWAIT.
+      def supports_nowait?
+        !db.mariadb? && db.server_version >= 80000
+      end
+
       # MySQL's DISTINCT ON emulation using GROUP BY does not respect the
       # query's ORDER BY clause.
       def supports_ordered_distinct_on?
@@ -777,14 +798,20 @@ module Sequel
         true
       end
 
+      # MySQL 8+ supports SKIP LOCKED.
+      def supports_skip_locked?
+        !db.mariadb? && db.server_version >= 80000
+      end
+
       # Check the database setting for whether fractional timestamps
       # are suppported.
       def supports_timestamp_usecs?
         db.supports_timestamp_usecs?
       end
 
+      # MariaDB 10.2+ and MySQL 8+ support window functions
       def supports_window_functions?
-        db.mariadb? && db.server_version >= 100200
+        db.server_version >= (db.mariadb? ? 100200 : 80000)
       end
 
       # Sets up the update methods to use UPDATE IGNORE.
@@ -946,8 +973,26 @@ module Sequel
       end
   
       # Support FOR SHARE locking when using the :share lock style.
+      # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
-        @opts[:lock] == :share ? (sql << ' LOCK IN SHARE MODE') : super
+        lock = @opts[:lock]
+        if lock == :share
+          if !db.mariadb? && db.server_version >= 80000
+            sql << ' FOR SHARE'
+          else
+            sql << ' LOCK IN SHARE MODE'
+          end
+        else
+          super
+        end
+
+        if lock
+          if @opts[:skip_locked]
+            sql << " SKIP LOCKED"
+          elsif @opts[:nowait]
+            sql << " NOWAIT"
+          end
+        end
       end
 
       # MySQL specific SQL_CALC_FOUND_ROWS option

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

@@ -225,6 +225,7 @@ module Sequel
         /check constraint .+ violated/ => CheckConstraintViolation,
         /cannot insert NULL into|cannot update .+ to NULL/ => NotNullConstraintViolation,
         /can't serialize access for this transaction/ => SerializationFailure,
+        /resource busy and acquire with NOWAIT specified or timeout/ => DatabaseLockTimeout,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -487,6 +488,11 @@ module Sequel
         false
       end
     
+      # Oracle supports NOWAIT.
+      def supports_nowait?
+        true
+      end
+
       # Oracle does not support offsets in correlated subqueries.
       def supports_offsets_in_correlated_subqueries?
         false
@@ -622,8 +628,12 @@ module Sequel
       def select_lock_sql(sql)
         super
 
-        if @opts[:skip_locked]
-          sql << " SKIP LOCKED"
+        if @opts[:lock]
+          if @opts[:skip_locked]
+            sql << " SKIP LOCKED"
+          elsif @opts[:nowait]
+            sql << " NOWAIT"
+          end
         end
       end
 

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

@@ -213,6 +213,32 @@ module Sequel
         run("COMMIT PREPARED #{literal(transaction_id)}", opts)
       end
 
+      # A hash of metadata for CHECK constraints on the table.
+      # Keys are CHECK constraint name symbols.  Values are hashes with the following keys:
+      # :definition :: An SQL fragment for the definition of the constraint
+      # :columns :: An array of column symbols for the columns referenced in the constraint
+      def check_constraints(table)
+        m = output_identifier_meth
+
+        rows = metadata_dataset.
+          from{pg_constraint.as(:co)}.
+          join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          where(:conrelid=>regclass_oid(table), :contype=>'c').
+          select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+
+        hash = {}
+        rows.each do |row|
+          constraint = m.call(row[:constraint])
+          if entry = hash[constraint]
+            entry[:columns] << m.call(row[:column])
+          else
+            hash[constraint] = {:definition=>row[:definition], :columns=>[m.call(row[:column])]}
+          end
+        end
+        
+        hash
+      end
+
       # Convert the first primary key column in the +table+ from being a serial column to being an identity column.
       # If the column is already an identity column, assume it was already converted and make no changes.
       #
@@ -396,67 +422,95 @@ module Sequel
 
       # Return full foreign key information using the pg system tables, including
       # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
+      #
+      # Supports additional options:
+      # :reverse :: Instead of returning foreign keys in the current table, return
+      #             foreign keys in other tables that reference the current table.
+      # :schema :: Set to true to have the :table value in the hashes be a qualified
+      #            identifier.  Set to false to use a separate :schema value with
+      #            the related schema.  Defaults to whether the given table argument
+      #            is a qualified identifier.
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
         oid = regclass_oid(table)
+        reverse = opts[:reverse]
+
+        if reverse
+          ctable = Sequel[:att2]
+          cclass = Sequel[:cl2]
+          rtable = Sequel[:att]
+          rclass = Sequel[:cl]
+        else
+          ctable = Sequel[:att]
+          cclass = Sequel[:cl]
+          rtable = Sequel[:att2]
+          rclass = Sequel[:cl2]
+        end
 
         if server_version >= 90500
-          cpos = Sequel.expr{array_position(co[:conkey], att[:attnum])}
-          rpos = Sequel.expr{array_position(co[:confkey], att2[:attnum])}
+          cpos = Sequel.expr{array_position(co[:conkey], ctable[:attnum])}
+          rpos = Sequel.expr{array_position(co[:confkey], rtable[:attnum])}
         else
           range = 0...32
-          cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, att[:attnum])}
-          rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, att2[:attnum])}
+          cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, ctable[:attnum])}
+          rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, rtable[:attnum])}
         end
 
         ds = metadata_dataset.
           from{pg_constraint.as(:co)}.
-          join(Sequel[:pg_class].as(:cl), :oid=>:conrelid).
-          join(Sequel[:pg_attribute].as(:att), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
-          join(Sequel[:pg_class].as(:cl2), :oid=>Sequel[:co][:confrelid]).
-          join(Sequel[:pg_attribute].as(:att2), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
+          join(Sequel[:pg_class].as(cclass), :oid=>:conrelid).
+          join(Sequel[:pg_attribute].as(ctable), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          join(Sequel[:pg_class].as(rclass), :oid=>Sequel[:co][:confrelid]).
+          join(Sequel[:pg_attribute].as(rtable), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
+          join(Sequel[:pg_namespace].as(:nsp), :oid=>Sequel[:cl2][:relnamespace]).
           order{[co[:conname], cpos]}.
           where{{
             cl[:relkind]=>'r',
             co[:contype]=>'f',
             cl[:oid]=>oid,
             cpos=>rpos
-            }}.
+          }}.
           select{[
             co[:conname].as(:name),
-            att[:attname].as(:column),
+            ctable[:attname].as(:column),
             co[:confupdtype].as(:on_update),
             co[:confdeltype].as(:on_delete),
             cl2[:relname].as(:table),
-            att2[:attname].as(:refcolumn),
-            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable)
+            rtable[:attname].as(:refcolumn),
+            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable),
+            nsp[:nspname].as(:schema)
           ]}
 
-        # If a schema is given, we only search in that schema, and the returned :table
-        # entry is schema qualified as well.
-        if schema
-          ds = ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
-            select_append{nsp2[:nspname].as(:schema)}
-        end
-
         h = {}
         fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 
 
         ds.each do |row|
-          if r = h[row[:name]]
+          if reverse
+            key = [row[:schema], row[:table], row[:name]]
+          else
+            key = row[:name]
+          end
+
+          if r = h[key]
             r[:columns] << m.call(row[:column])
             r[:key] << m.call(row[:refcolumn])
           else
-            h[row[:name]] = {
+            entry = h[key] = {
               :name=>m.call(row[:name]),
               :columns=>[m.call(row[:column])],
               :key=>[m.call(row[:refcolumn])],
               :on_update=>fklod_map[row[:on_update]],
               :on_delete=>fklod_map[row[:on_delete]],
               :deferrable=>row[:deferrable],
-              :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table])
+              :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table]),
             }
+
+            unless schema
+              # If not combining schema information into the :table entry
+              # include it as a separate entry.
+              entry[:schema] = m.call(row[:schema])
+            end
           end
         end
 
@@ -494,12 +548,12 @@ module Sequel
             indc[:relkind]=>'i',
             ind[:indisprimary]=>false,
             :indexprs=>nil,
-            :indpred=>nil,
             :indisvalid=>true,
             tab[:oid]=>oid}}.
           order(*order).
           select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
+        ds = ds.where(:indpred=>nil) unless opts[:include_partial]
         ds = ds.where(:indisready=>true) if server_version >= 80300
         ds = ds.where(:indislive=>true) if server_version >= 90300
 
@@ -809,12 +863,12 @@ module Sequel
 
       VALID_CLIENT_MIN_MESSAGES = %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze.each(&:freeze)
       # The SQL queries to execute when starting a new connection.
-      def connection_configuration_sqls
+      def connection_configuration_sqls(opts=@opts)
         sqls = []
 
-        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, true))
+        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(opts.fetch(:force_standard_strings, true))
 
-        cmm = @opts.fetch(:client_min_messages, :warning)
+        cmm = opts.fetch(:client_min_messages, :warning)
         if cmm && !cmm.to_s.empty?
           cmm = cmm.to_s.upcase.strip
           unless VALID_CLIENT_MIN_MESSAGES.include?(cmm)
@@ -823,7 +877,7 @@ module Sequel
           sqls << "SET client_min_messages = '#{cmm.to_s.upcase}'"
         end
 
-        if search_path = @opts[:search_path]
+        if search_path = opts[:search_path]
           case search_path
           when String
             search_path = search_path.split(",").map(&:strip)
@@ -863,6 +917,8 @@ module Sequel
           ExclusionConstraintViolation
         elsif sqlstate == '40P01'
           SerializationFailure
+        elsif sqlstate == '55P03'
+          DatabaseLockTimeout
         else
           super
         end
@@ -878,6 +934,7 @@ module Sequel
         [/violates not-null constraint/, NotNullConstraintViolation],
         [/conflicting key value violates exclusion constraint/, ExclusionConstraintViolation],
         [/could not serialize access/, SerializationFailure],
+        [/could not obtain lock on row in relation/, DatabaseLockTimeout],
       ].freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -1577,6 +1634,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL supports NOWAIT.
+      def supports_nowait?
+        true
+      end
+
       # Returning is always supported.
       def supports_returning?(type)
         true
@@ -1796,14 +1858,19 @@ module Sequel
       # Support FOR SHARE locking when using the :share lock style.
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
-        if @opts[:lock] == :share
+        lock = @opts[:lock]
+        if lock == :share
           sql << ' FOR SHARE'
         else
           super
         end
 
-        if @opts[:skip_locked]
-          sql << " SKIP LOCKED"
+        if lock
+          if @opts[:skip_locked]
+            sql << " SKIP LOCKED"
+          elsif @opts[:nowait]
+            sql << " NOWAIT"
+          end
         end
       end