sequel 4.36.0 → 4.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb4a5a3794c2842c41482c01c74e82c2eed2f548
-  data.tar.gz: b4e04bef12f7580b1fa3857a9a6d820ce5e977df
+  metadata.gz: e32a73f763f4abf6ea2b3e2833cd0d0a85356842
+  data.tar.gz: 9856a7e6a4c175f16c745339609b8b4d3d6b4d61
 SHA512:
-  metadata.gz: b35ce656b26c851e5b5e2bf19c4ce5a40e83f6d79d939561a6e2d584b5210f91cbef788dbbb0a6c47154baa91f039eea6fb81053bdb03f016bf2a40a0da0f5eb
-  data.tar.gz: 829169bda7ea5e43e8ef6d6b9726ba950adb033e6a4f992a3fb677cded90ca1ec842bb90632ba21aa15b4c6184db0fb45d3ce37b908e9d8fcd4f1591e13a7954
+  metadata.gz: 5286ffd2c900e56b4d07598dd6ecb4fcdf7bfd5694a56537ba4ca29a55f1801055e42d6ccd2b49c2aa655065f63380d8f068ef55602bb81c768947540788afa4
+  data.tar.gz: 842a025e1ecdcbe2990dbfd5f40ebcf2d9db9408d73e62e73ef4c36e0a56c27affa76a60d780845abb34d23e3108d6783fb3f206f7a13f304daad868d62b2667

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 4.37.0 (2016-08-01)
+
+* Add support for regular expression matching on Oracle 10g+ using REGEXP_LIKE (johndcaldwell) (#1221)
+
+* Recognize an additional disconnect error in the postgres adapter (jeremyevans)
+
+* Make connection pool remove connections for disconnect errors not raised as DatabaseDisconnectError (jeremyevans)
+
+* Support mysql2 0.4+ native prepared statements and bound variables (jeremyevans)
+
+* Add Database#values for VALUES support on SQLite 3.8.3+ (jeremyevans)
+
+* Support create_view :columns option on SQLite 3.9.0+ (jeremyevans)
+
+* Make migration reverser handle alter_table add_constraint using a hash as the first argument (soupmatt) (#1215)
+
+* Make ASTTransformer handle Sequel.extract (jeremyevans) (#1213)
+
 === 4.36.0 (2016-07-01)
 
 * Deprecate use of Bignum class as generic type, since the behavior will change in ruby 2.4 (jeremyevans)

data/Rakefile

@@ -6,7 +6,7 @@ VERS = lambda do
   require File.expand_path("../lib/sequel/version", __FILE__)
   Sequel.version
 end
-CLEAN.include ["**/.*.sw?", "sequel-*.gem", ".config", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc*", '**/*.rbc']
+CLEAN.include ["**/.*.sw?", "sequel-*.gem", ".config", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc*", '**/*.rbc', "spec/bin-sequel-*"]
 
 # Gem Packaging and Release
 

data/doc/prepared_statements.rdoc

@@ -7,8 +7,8 @@ the following adapters:
 
 * ibmdb (prepared statements only)
 * jdbc
-* mysql (prepared statements only)
-* mysql2 (prepared statements only)
+* mysql (server prepared statements using literalized connection variables)
+* mysql2 (full support on 0.4+, otherwise server prepared statements using literalized connection variables)
 * oracle (requires type specifiers for nil/NULL values)
 * postgres (when using the pg driver)
 * sqlite

data/doc/release_notes/4.35.0.txt

@@ -56,7 +56,7 @@
     Example.first.lock!('FOR NO KEY UPDATE')
     #=> SELECT * FROM examples WHERE id = 1 FOR NO KEY UPDATE LIMIT 1
 
-* Sequel::Database#skip_locked has been added, which skips locked rows
+* Sequel::Dataset#skip_locked has been added, which skips locked rows
   when returning query results. This is useful whenever you are
   implementing a queue or similar data structure.  Currently, this is
   supported on PostgreSQL 9.5+, Oracle, and Microsoft SQL Server.

data/doc/release_notes/4.37.0.txt

@@ -0,0 +1,50 @@
+= New Features
+
+* Database#values has been added on SQLite#3.8.3+, operating similarly
+  to the support on PostgreSQL:
+
+    DB.values([[1, 2], [3, 4]]).select_map([:column1, :column2])
+    # => [[1, 2], [3, 4]]
+
+* Regular expressions in dataset filters are now supported on Oracle
+  10g+:
+
+    DB[:t].where(:c=>/re/)
+    # SELECT * FROM "T" WHERE REGEXP_LIKE("C",'re')
+
+= Other Improvements
+
+* Sequel now supports the use of native prepared statements and bound
+  variables in the mysql2 adapter, when mysql2 0.4+ is used.
+  Previously, the mysql2 adapter supported database prepared
+  statements, but variables were always literalized.  That is still
+  supported when mysql2 <0.4 is used.
+
+* The connection pool now removes connections if it detects a
+  disconnect error that is not raised as a
+  Sequel::DatabaseDisconnectError.  Such exceptions are reraised
+  without converted them to Sequel::DatabaseDisconnectError, but the
+  related connection is now removed from the pool.
+
+* The reversible migration support now handles add_constraint with an
+  options hash as the first argument.
+
+* ASTTransformer now handles Sequel.extract, allowing Dataset#qualify
+  and other uses of ASTTransformer to work with such values.
+
+* The create_view :columns option is now suppported on SQLite 3.9.0+.
+
+* An additional disconnect error is now recognized in the postgres
+  adapter.
+
+* A frozen string literal issue has been fixed when multiple different 
+  database connection approaches have failed in the jdbc adapter.
+
+= Backwards Compatibility
+
+* External database adapters need to make sure that
+  Database#database_error_classes returns a valid result if called
+  during Database#initialize.  If you have an external adapter where
+  one of the error classes depends on an argument given when
+  connecting (such as the connection string), you may have to make
+  some changes.

data/doc/schema_modification.rdoc

@@ -519,6 +519,12 @@ This modifies the default value of a column:
     set_column_default :copies_sold, 0
   end
 
+To remove a default value for a column, use +nil+ as the value:
+
+  alter_table(:albums) do
+    set_column_default :copies_sold, nil
+  end
+
 === +set_column_type+
 
 This modifies a column's type.  Most databases will attempt to convert existing values in

data/lib/sequel/adapters/jdbc.rb

@@ -224,7 +224,7 @@ module Sequel
               c
             rescue JavaSQL::SQLException, NativeException, StandardError => e2
               unless e2.message == e.message
-                e2.message << "\n#{e.class.name}: #{e.message}"
+                e2.message = "#{e2.message}\n#{e.class.name}: #{e.message}"
               end
               raise e2
             end

data/lib/sequel/adapters/mock.rb

@@ -53,7 +53,7 @@ module Sequel
       SHARED_ADAPTER_SETUP = {
         'postgres' => lambda do |db|
           db.instance_eval do
-            @server_version = 90400
+            @server_version = 90500
             initialize_postgres_adapter
           end
           db.extend(Module.new do
@@ -68,6 +68,7 @@ module Sequel
         end,
         'oracle' => lambda do |db|
           db.instance_eval do
+            @server_version = 11000000
             @primary_key_sequences = {}
           end
         end,
@@ -83,7 +84,7 @@ module Sequel
         end,
         'sqlite' => lambda do |db|
           db.instance_eval do
-            @sqlite_version = 30804
+            @sqlite_version = 30903
           end
         end
       }

data/lib/sequel/adapters/mysql.rb

@@ -7,7 +7,7 @@ rescue LoadError
 end
 raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!\n  You are probably using the pure ruby mysql.rb driver,\n  which Sequel does not support. You need to install\n  the C based adapter, and make sure that the mysql.so\n  file is loaded instead of the mysql.rb file.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
-Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
+Sequel.require %w'utils/mysql_mysql2 utils/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
@@ -41,6 +41,7 @@ module Sequel
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      include Sequel::MySQL::MysqlMysql2::DatabaseMethods
       include Sequel::MySQL::PreparedStatements::DatabaseMethods
       
       # Regular expression used for getting accurate number of rows
@@ -287,6 +288,7 @@ module Sequel
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
+      include Sequel::MySQL::MysqlMysql2::DatasetMethods
       include Sequel::MySQL::PreparedStatements::DatasetMethods
 
       Database::DatasetClass = self

data/lib/sequel/adapters/mysql2.rb

@@ -1,15 +1,23 @@
 # frozen-string-literal: true
 
 require 'mysql2'
-Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
+Sequel.require %w'utils/mysql_mysql2', 'adapters'
 
 module Sequel
   # Module for holding all Mysql2-related classes and modules for Sequel.
   module Mysql2
+    NativePreparedStatements = if ::Mysql2::VERSION >= '0.4'
+      true
+    else
+      Sequel.require %w'utils/mysql_prepared_statements', 'adapters'
+      false
+    end
+
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
-      include Sequel::MySQL::PreparedStatements::DatabaseMethods
+      include Sequel::MySQL::MysqlMysql2::DatabaseMethods
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods unless NativePreparedStatements
 
       set_adapter_scheme :mysql2
       
@@ -37,6 +45,10 @@ module Sequel
         opts[:encoding] ||= opts[:charset]
         conn = ::Mysql2::Client.new(opts)
         conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
+          
+        if NativePreparedStatements
+          @default_query_options ||= conn.query_options.dup
+        end
 
         sqls = mysql_connection_setting_sqls
 
@@ -71,13 +83,60 @@ module Sequel
 
       private
 
+      if NativePreparedStatements
+        # Use a native mysql2 prepared statement to implement prepared statements.
+        def execute_prepared_statement(ps_name, opts, &block)
+          args = opts[:arguments]
+          ps = prepared_statement(ps_name)
+          sql = ps.prepared_sql
+
+          synchronize(opts[:server]) do |conn|
+            stmt, ps_sql = conn.prepared_statements[ps_name]
+            unless ps_sql == sql
+              stmt.close if stmt
+              stmt = log_connection_yield(conn, "Preparing #{ps_name}: #{sql}"){conn.prepare(sql)}
+              conn.prepared_statements[ps_name] = [stmt, sql]
+            end
+
+            if ps.log_sql
+              opts = Hash[opts]
+              opts = opts[:log_sql] = " (#{sql})"
+            end
+
+            _execute(conn, stmt, opts, &block)
+          end
+        end
+      end
+
       # Execute the given SQL on the given connection.  If the :type
       # option is :select, yield the result of the query, otherwise
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
           stream = opts[:stream]
-          r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream)}
+          if NativePreparedStatements
+            if args = opts[:arguments]
+              args = args.map{|arg| bound_variable_value(arg)}
+            end
+
+            case sql
+            when ::Mysql2::Statement
+              stmt = sql
+            when Dataset
+              sql = sql.sql
+              close_stmt = true
+              stmt = conn.prepare(sql)
+            end
+          end
+
+          r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn, args) do
+            if stmt
+              conn.query_options.merge!(:cache_rows=>true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream, :cast_booleans=>convert_tinyint_to_bool)
+              stmt.execute(*args)
+            else
+              conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream)
+            end
+          end
           if opts[:type] == :select
             if r
               if stream
@@ -98,6 +157,11 @@ module Sequel
           end
         rescue ::Mysql2::Error => e
           raise_error(e)
+        ensure
+          if stmt
+            conn.query_options.replace(@default_query_options)
+            stmt.close if close_stmt
+          end
         end
       end
 
@@ -106,6 +170,22 @@ module Sequel
         self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
       end
 
+      if NativePreparedStatements
+        # Handle bound variable arguments that Mysql2 does not handle natively.
+        def bound_variable_value(arg)
+          case arg
+          when true
+            1
+          when false
+            0
+          when DateTime, Time
+            literal(arg)[1...-1]
+          else
+            arg
+          end
+        end
+      end
+
       # MySQL connections use the query method to execute SQL without a result
       def connection_execute_method
         :query
@@ -146,11 +226,31 @@ module Sequel
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
-      include Sequel::MySQL::PreparedStatements::DatasetMethods
+      include Sequel::MySQL::MysqlMysql2::DatasetMethods
+      include Sequel::MySQL::PreparedStatements::DatasetMethods unless NativePreparedStatements
       STREAMING_SUPPORTED = ::Mysql2::VERSION >= '0.3.12'
 
       Database::DatasetClass = self
 
+      if NativePreparedStatements
+        PreparedStatementMethods = prepared_statements_module(
+          "sql = self; opts = Hash[opts]; opts[:arguments] = bind_arguments",
+          Sequel::Dataset::UnnumberedArgumentMapper,
+          %w"execute execute_dui execute_insert")
+
+        # Create a named prepared statement that is stored in the
+        # database (and connection) for reuse.
+        def prepare(type, name=nil, *values)
+          ps = to_prepared_statement(type, values)
+          ps.extend(PreparedStatementMethods)
+          if name
+            ps.prepared_statement_name = name
+            db.set_prepared_statement(name, ps)
+          end
+          ps
+        end
+      end
+
       # Yield all rows matching this dataset.
       def fetch_rows(sql)
         execute(sql) do |r|
@@ -199,16 +299,7 @@ module Sequel
 
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
       def literal_string_append(sql, v)
-        s = begin
-          db.synchronize(@opts[:server]) do |c| 
-            begin
-              c.escape(v)
-            rescue ::Mysql2::Error => e
-              db.send(:raise_error, e)
-            end
-          end
-        end
-
+        s = db.synchronize(@opts[:server]){|c| c.escape(v)}
         sql << APOS << s << APOS
       end
     end

data/lib/sequel/adapters/postgres.rb

@@ -125,6 +125,7 @@ module Sequel
         'could not receive data from server',
         'no connection to the server',
         'connection not open',
+        'connection is closed',
         'terminating connection due to administrator command',
         'PQconsumeInput() '
        ]
@@ -560,6 +561,12 @@ module Sequel
         [PGError]
       end
 
+      def disconnect_error?(exception, opts)
+        super ||
+          Adapter::DISCONNECT_ERROR_CLASSES.any?{|klass| exception.is_a?(klass)} ||
+          exception.message =~ Adapter::DISCONNECT_ERROR_RE
+      end
+
       def database_exception_sqlstate(exception, opts)
         if exception.respond_to?(:result) && (result = exception.result)
           result.error_field(::PGresult::PG_DIAG_SQLSTATE)
@@ -841,12 +848,12 @@ module Sequel
       
       # Use the driver's escape_bytea
       def literal_blob_append(sql, v)
-        sql << APOS << db.synchronize(@opts[:server]){|c| c.check_disconnect_errors{c.escape_bytea(v)}} << APOS
+        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_bytea(v)} << APOS
       end
       
       # Use the driver's escape_string
       def literal_string_append(sql, v)
-        sql << APOS << db.synchronize(@opts[:server]){|c| c.check_disconnect_errors{c.escape_string(v)}} << APOS
+        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
       end
       
       # For each row in the result set, yield a hash with column name symbol

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

@@ -90,6 +90,23 @@ module Sequel
           count > 0
       end 
 
+      # The version of the Oracle server, used for determining capability.
+      def server_version(server=nil)
+        return @server_version if @server_version
+        @server_version = synchronize(server) do |conn|
+          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
+        end
+        unless @server_version
+          @server_version = if m = /(\d+)\.(\d+)\.?(\d+)?\.?(\d+)?/.match(fetch("select version from PRODUCT_COMPONENT_VERSION where lower(product) like 'oracle%'").single_value)
+            (m[1].to_i*1000000) + (m[2].to_i*10000) + (m[3].to_i*100) + m[4].to_i
+          else
+            0
+          end
+        end
+        @server_version
+      end
+
+
       # Oracle supports deferrable constraints.
       def supports_deferrable_constraints?
         true
@@ -305,6 +322,19 @@ module Sequel
             s2 = complex_expression_arg_pairs(x, &BITAND_PROC)
             Sequel.lit(["(", " - ", ")"], s1, s2)
           end
+        when :~, :'!~', :'~*', :'!~*'
+          raise InvalidOperation, "Pattern matching via regular expressions is not supported in this Oracle version" unless supports_regexp?
+          if op == :'!~' || op == :'!~*'
+            sql << 'NOT '
+          end
+          sql << 'REGEXP_LIKE('
+          literal_append(sql, args.at(0))
+          sql << ','
+          literal_append(sql, args.at(1))
+          if op == :'~*' || op == :'!~*'
+            sql << ", 'i'"
+          end
+          sql << ')'
         when :%, :<<, :>>, :'B~'
           complex_expression_emulate_append(sql, op, args)
         else
@@ -452,6 +482,16 @@ module Sequel
         true
       end
 
+      # The version of the database server
+      def server_version
+        db.server_version(@opts[:server])
+      end
+
+      # Oracle supports pattern matching via regular expressions
+      def supports_regexp?
+        server_version >= 10010002
+      end
+
       private
 
       # Allow preparing prepared statements, since determining the prepared sql to use for

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

@@ -204,6 +204,14 @@ module Sequel
         pragma_set(:temp_store, value)
       end
       
+      # Creates a dataset that uses the VALUES clause:
+      #
+      #   DB.values([[1, 2], [3, 4]])
+      #   VALUES ((1, 2), (3, 4))
+      def values(v)
+        @default_dataset.clone(:values=>v)
+      end
+
       # Array of symbols specifying the view names in the current database.
       #
       # Options:
@@ -328,7 +336,7 @@ module Sequel
 
       # SQLite support creating temporary views.
       def create_view_prefix_sql(name, options)
-        "CREATE #{'TEMPORARY 'if options[:temp]}VIEW #{quote_schema_table(name)}"
+        create_view_sql_append_columns("CREATE #{'TEMPORARY 'if options[:temp]}VIEW #{quote_schema_table(name)}", options[:columns])
       end
 
       DATABASE_ERROR_REGEXPS = {
@@ -517,9 +525,11 @@ module Sequel
       DATETIME_OPEN = "datetime(".freeze
       ONLY_OFFSET = " LIMIT -1 OFFSET ".freeze
       OR = " OR ".freeze
+      SELECT_VALUES = "VALUES ".freeze
 
       Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
       Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values'], ["else", %w'insert conflict into columns values']])
+      Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
@@ -747,6 +757,12 @@ module Sequel
         literal_append(sql, @opts[:offset])
       end
   
+      # Support VALUES clause instead of the SELECT clause to return rows.
+      def select_values_sql(sql)
+        sql << SELECT_VALUES
+        expression_list_append(sql, opts[:values])
+      end
+
       # SQLite supports quoted function names.
       def supports_quoted_function_names?
         true

data/lib/sequel/adapters/swift.rb

@@ -12,19 +12,16 @@ module Sequel
     # Contains procs keyed on sub adapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {:postgres=>proc do |db|
-        Sequel.require 'adapters/swift/postgres'
         db.extend(Sequel::Swift::Postgres::DatabaseMethods)
         db.extend_datasets Sequel::Postgres::DatasetMethods
         db.swift_class = ::Swift::DB::Postgres
       end,
       :mysql=>proc do |db|
-        Sequel.require 'adapters/swift/mysql'
         db.extend(Sequel::Swift::MySQL::DatabaseMethods)
         db.dataset_class = Sequel::Swift::MySQL::Dataset
         db.swift_class = ::Swift::DB::Mysql
       end,
       :sqlite=>proc do |db|
-        Sequel.require 'adapters/swift/sqlite'
         db.extend(Sequel::Swift::SQLite::DatabaseMethods)
         db.dataset_class = Sequel::Swift::SQLite::Dataset
         db.swift_class = ::Swift::DB::Sqlite3
@@ -38,6 +35,11 @@ module Sequel
       # The Swift adapter class being used by this database.  Connections
       # in this database's connection pool will be instances of this class.
       attr_accessor :swift_class
+
+      def initialize(opts=OPTS)
+        Sequel.require "adapters/swift/#{opts[:db_type]}" if %w'postgres mysql sqlite'.include?(opts[:db_type].to_s)
+        super
+      end
       
       # Create an instance of swift_class for the given options.
       def connect(server)

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -0,0 +1,82 @@
+# frozen-string-literal: true
+
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+
+module Sequel
+  module MySQL
+    # This module is used by the mysql and mysql2 adapters to support
+    # prepared statements and stored procedures.
+    module MysqlMysql2
+      module DatabaseMethods
+        disconnect_errors = <<-END.split("\n").map(&:strip)
+        Commands out of sync; you can't run this command now
+        Can't connect to local MySQL server through socket
+        MySQL server has gone away
+        Lost connection to MySQL server during query
+        This connection is still waiting for a result, try again once you have the result
+        closed MySQL connection
+        END
+        # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
+       
+        # Support stored procedures on MySQL
+        def call_sproc(name, opts=OPTS, &block)
+          args = opts[:args] || [] 
+          execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+        end
+        
+        # Executes the given SQL using an available connection, yielding the
+        # connection if the block is given.
+        def execute(sql, opts=OPTS, &block)
+          if opts[:sproc]
+            call_sproc(sql, opts, &block)
+          elsif sql.is_a?(Symbol)
+            execute_prepared_statement(sql, opts, &block)
+          else
+            synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+          end
+        end
+        
+        private
+
+        def add_prepared_statements_cache(conn)
+          class << conn
+            attr_accessor :prepared_statements
+          end
+          conn.prepared_statements = {}
+        end
+
+        # Stupid MySQL doesn't use SQLState error codes correctly, mapping
+        # all constraint violations to 23000 even though it recognizes
+        # different types.
+        def database_specific_error_class(exception, opts)
+          case exception.errno
+          when 1048
+            NotNullConstraintViolation
+          when 1062
+            UniqueConstraintViolation
+          when 1451, 1452
+            ForeignKeyConstraintViolation
+          else
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        include Sequel::Dataset::StoredProcedures
+       
+        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
+          "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
+          Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
+        
+        private
+
+        # Extend the dataset with the MySQL stored procedure methods.
+        def prepare_extend_sproc(ds)
+          ds.extend(StoredProcedureMethods)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/{shared → utils}/mysql_prepared_statements.rb

@@ -1,67 +1,11 @@
 # frozen-string-literal: true
 
-Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
-
 module Sequel
   module MySQL
-    # This module is used by the mysql and mysql2 adapters to support
-    # prepared statements and stored procedures.
     module PreparedStatements
       module DatabaseMethods
-        disconnect_errors = <<-END.split("\n").map(&:strip)
-        Commands out of sync; you can't run this command now
-        Can't connect to local MySQL server through socket
-        MySQL server has gone away
-        Lost connection to MySQL server during query
-        This connection is still waiting for a result, try again once you have the result
-        closed MySQL connection
-        END
-        # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
-        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
-       
-        # Support stored procedures on MySQL
-        def call_sproc(name, opts=OPTS, &block)
-          args = opts[:args] || [] 
-          execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
-        end
-        
-        # Executes the given SQL using an available connection, yielding the
-        # connection if the block is given.
-        def execute(sql, opts=OPTS, &block)
-          if opts[:sproc]
-            call_sproc(sql, opts, &block)
-          elsif sql.is_a?(Symbol)
-            execute_prepared_statement(sql, opts, &block)
-          else
-            synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-          end
-        end
-        
         private
 
-        def add_prepared_statements_cache(conn)
-          class << conn
-            attr_accessor :prepared_statements
-          end
-          conn.prepared_statements = {}
-        end
-
-        # Stupid MySQL doesn't use SQLState error codes correctly, mapping
-        # all constraint violations to 23000 even though it recognizes
-        # different types.
-        def database_specific_error_class(exception, opts)
-          case exception.errno
-          when 1048
-            NotNullConstraintViolation
-          when 1062
-            UniqueConstraintViolation
-          when 1451, 1452
-            ForeignKeyConstraintViolation
-          else
-            super
-          end
-        end
-
         # Executes a prepared statement on an available connection.  If the
         # prepared statement already exists for the connection and has the same
         # SQL, reuse it, otherwise, prepare the new statement.  Because of the
@@ -86,8 +30,6 @@ module Sequel
       end
 
       module DatasetMethods
-        include Sequel::Dataset::StoredProcedures
-       
         # Methods to add to MySQL prepared statement calls without using a
         # real database prepared statement and bound variables.
         module CallableStatementMethods
@@ -112,10 +54,6 @@ module Sequel
             end
         end
         
-        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
-          "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
-          Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
-        
         # MySQL is different in that it supports prepared statements but not bound
         # variables outside of prepared statements.  The default implementation
         # breaks the use of subselects in prepared statements, so extend the
@@ -138,14 +76,6 @@ module Sequel
           end
           ps
         end
-        
-        private
-
-        # Extend the dataset with the MySQL stored procedure methods.
-        def prepare_extend_sproc(ds)
-          ds.extend(StoredProcedureMethods)
-        end
-        
       end
     end
   end

data/lib/sequel/ast_transformer.rb

@@ -26,8 +26,14 @@ module Sequel
         h = {}
         o.each{|k, val| h[v(k)] = v(val)}
         h
+      when SQL::NumericExpression
+        if o.op == :extract
+          o.class.new(o.op, o.args[0], v(o.args[1]))
+        else
+          o.class.new(o.op, *v(o.args))
+        end
       when SQL::ComplexExpression
-        SQL::ComplexExpression.new(o.op, *v(o.args))
+        o.class.new(o.op, *v(o.args))
       when SQL::Identifier
         SQL::Identifier.new(v(o.value))
       when SQL::QualifiedIdentifier

data/lib/sequel/connection_pool.rb

@@ -84,6 +84,7 @@ class Sequel::ConnectionPool
   def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]
+    @error_classes = db.send(:database_error_classes).dup.freeze
   end
   
   # Alias for +size+, not aliased directly for ease of subclass implementation
@@ -102,6 +103,11 @@ class Sequel::ConnectionPool
   def disconnect_connection(conn)
     db.disconnect_connection(conn)
   end
+
+  # Whether the given exception is a disconnect exception.
+  def disconnect_error?(exception)
+    exception.is_a?(Sequel::DatabaseDisconnectError) || db.send(:disconnect_error?, exception, OPTS)
+  end
   
   # Return a new connection by calling the connection proc with the given server name,
   # and checking for connection errors.

data/lib/sequel/connection_pool/sharded_single.rb

@@ -50,8 +50,8 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     begin
       server = pick_server(server)
       yield(@conns[server] ||= make_new(server))
-    rescue Sequel::DatabaseDisconnectError
-      disconnect_server(server)
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      disconnect_server(server) if disconnect_error?(e)
       raise
     end
   end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -126,8 +126,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     begin
       conn = acquire(t, server)
       yield conn
-    rescue Sequel::DatabaseDisconnectError
-      sync{@connections_to_remove << conn} if conn
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      sync{@connections_to_remove << conn} if conn && disconnect_error?(e)
       raise
     ensure
       sync{release(t, conn, server)} if conn

data/lib/sequel/connection_pool/single.rb

@@ -20,8 +20,8 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   def hold(server=nil)
     begin
       yield(@conn ||= make_new(DEFAULT_SERVER))
-    rescue Sequel::DatabaseDisconnectError
-      disconnect
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      disconnect if disconnect_error?(e)
       raise
     end
   end

data/lib/sequel/connection_pool/threaded.rb

@@ -105,11 +105,13 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     begin
       conn = acquire(t)
       yield conn
-    rescue Sequel::DatabaseDisconnectError
-      oconn = conn
-      conn = nil
-      disconnect_connection(oconn) if oconn
-      @allocated.delete(t)
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      if disconnect_error?(e)
+        oconn = conn
+        conn = nil
+        disconnect_connection(oconn) if oconn
+        @allocated.delete(t)
+      end
       raise
     ensure
       sync{release(t)} if conn

data/lib/sequel/database/schema_generator.rb

@@ -494,6 +494,10 @@ module Sequel
       #
       #   set_column_default(:artist_name, 'a') # ALTER COLUMN artist_name SET DEFAULT 'a'
       #
+      # To remove an existing default value, use +nil+ as the value:
+      #
+      #   set_column_default(:artist_name, nil) # ALTER COLUMN artist_name SET DEFAULT NULL
+      #
       # On MySQL, make sure to use a symbol for the name of the column, as otherwise you
       # can lose the type and NULL/NOT NULL setting for the column.
       def set_column_default(name, default)

data/lib/sequel/extensions/migration.rb

@@ -245,7 +245,9 @@ module Sequel
     end
 
     def add_constraint(*args)
-      @actions << [:drop_constraint, args.first]
+      name = args.first
+      name = name.is_a?(Hash) ? name[:name] : name
+      @actions << [:drop_constraint, name]
     end
 
     def add_foreign_key(key, table, *args)

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 36
+  MINOR = 37
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/sqlite_spec.rb

@@ -190,6 +190,24 @@ describe "SQLite temporary views" do
   end
 end
     
+describe "SQLite VALUES support" do
+  before do
+    @db = DB
+  end
+
+  it "should create a dataset using the VALUES clause via #values" do
+    @db.values([[1, 2], [3, 4]]).map([:column1, :column2]).must_equal [[1, 2], [3, 4]]
+  end
+
+  it "should support VALUES with unions" do
+    @db.values([[1]]).union(@db.values([[3]])).map(&:values).map(&:first).must_equal [1, 3]
+  end
+
+  it "should support VALUES in CTEs" do
+    @db[:a].cross_join(:b).with(:a, @db.values([[1, 2]]), :args=>[:c1, :c2]).with(:b, @db.values([[3, 4]]), :args=>[:c3, :c4]).map([:c1, :c2, :c3, :c4]).must_equal [[1, 2, 3, 4]]
+  end
+end if DB.sqlite_version >= 30803
+
 describe "SQLite type conversion" do
   before do
     @db = DB

data/spec/core/connection_pool_spec.rb

@@ -125,13 +125,13 @@ end
 
 describe "A connection pool handling connection errors" do 
   it "#hold should raise a Sequel::DatabaseConnectionError if an exception is raised by the connection_proc" do
-    cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){raise Interrupt}
+    cpool = Sequel::ConnectionPool.get_pool(mock_db.call{raise Interrupt}, CONNECTION_POOL_DEFAULTS)
     proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
     cpool.created_count.must_equal 0
   end
 
   it "#hold should raise a Sequel::DatabaseConnectionError if nil is returned by the connection_proc" do
-    cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){nil}
+    cpool = Sequel::ConnectionPool.get_pool(mock_db.call{nil}, CONNECTION_POOL_DEFAULTS)
     proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
     cpool.created_count.must_equal 0
   end
@@ -905,6 +905,48 @@ describe "A single threaded pool with multiple servers" do
 end
 
 AllConnectionPoolClassesSpecs = shared_description do
+  it "should have pool correctly handle disconnect errors not raised as DatabaseDisconnectError" do
+    db = mock_db.call{Object.new}
+    def db.dec; @dec ||= Class.new(StandardError) end
+    def db.database_error_classes; super + [dec] end
+    def db.disconnect_error?(e, opts); e.message =~ /foo/ end
+    cp = @class.new(db, {})
+
+    conn = nil
+    cp.hold do |c|
+      conn = c
+    end
+
+    proc do
+      cp.hold do |c|
+        c.must_equal conn
+        raise db.dec, "bar"
+      end
+    end.must_raise db.dec
+
+    proc do
+      cp.hold do |c|
+        c.must_equal conn
+        raise StandardError
+      end
+    end.must_raise StandardError
+
+    cp.hold do |c|
+      c.must_equal conn
+    end
+
+    proc do
+      cp.hold do |c|
+        c.must_equal conn
+        raise db.dec, "foo"
+      end
+    end.must_raise db.dec
+
+    cp.hold do |c|
+      c.wont_equal conn
+    end
+  end
+
   it "should have pool_type return a symbol" do
     @class.new(mock_db.call{123}, {}).pool_type.must_be_kind_of(Symbol)
   end

data/spec/core/dataset_spec.rb

@@ -3888,6 +3888,10 @@ describe "Sequel::Dataset#qualify" do
     @ds.select{sum(:a).order(:a)}.qualify.sql.must_equal 'SELECT sum(t.a ORDER BY t.a) FROM t'
   end
 
+  it "should handle Sequel.extract" do
+    @ds.select(Sequel.extract(:year, :d)).qualify.sql.must_equal 'SELECT extract(year FROM t.d) FROM t'
+  end
+
   it "should handle SQL::DelayedEvaluation" do
     t = :a
     ds = @ds.filter(Sequel.delay{t}).qualify

data/spec/core/mock_adapter_spec.rb

@@ -444,10 +444,11 @@ describe "Sequel Mock Adapter" do
   end
 
   it "should automatically set version for adapters nedding versions" do
-    Sequel.mock(:host=>'postgres').server_version.must_equal 90400
-    Sequel.mock(:host=>'mssql').server_version.must_equal 11000000
-    Sequel.mock(:host=>'mysql').server_version.must_equal 50617
-    Sequel.mock(:host=>'sqlite').sqlite_version.must_equal 30804
+    Sequel.mock(:host=>'postgres').server_version.must_be :>=, 90400
+    Sequel.mock(:host=>'mssql').server_version.must_be :>=, 11000000
+    Sequel.mock(:host=>'mysql').server_version.must_be :>=, 50617
+    Sequel.mock(:host=>'sqlite').sqlite_version.must_be :>=, 30804
+    Sequel.mock(:host=>'oracle').server_version.must_be :>=, 11000000
   end
 
   it "should stub out the primary_key method for postgres" do

data/spec/extensions/migration_spec.rb

@@ -129,6 +129,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
       alter_table(:b) do
         add_column :d, String
         add_constraint :blah, 'd IS NOT NULL'
+        add_constraint({:name=>:merp}, 'a > 1')
         add_foreign_key :e, :b
         add_foreign_key [:e], :b, :name=>'e_fk'
         add_foreign_key [:e, :a], :b
@@ -154,6 +155,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
       [:alter_table, [
         [:add_column, :d, String],
         [:add_constraint, :blah, "d IS NOT NULL"],
+        [:add_constraint, {:name=>:merp}, "a > 1"],
         [:add_foreign_key, :e, :b],
         [:add_foreign_key, [:e], :b, {:name=>"e_fk"}],
         [:add_foreign_key, [:e, :a], :b],
@@ -182,6 +184,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
         [:drop_foreign_key, [:e, :a]],
         [:drop_foreign_key, [:e], {:name=>"e_fk"}],
         [:drop_foreign_key, :e],
+        [:drop_constraint, :merp],
         [:drop_constraint, :blah],
         [:drop_column, :d]]
       ],

data/spec/extensions/pg_json_spec.rb

@@ -47,7 +47,7 @@ describe "pg_json extension" do
 
   it "should raise an error when attempting to parse invalid json" do
     proc{@m.parse_json('')}.must_raise(Sequel::InvalidValue)
-    proc{@m.parse_json('1')}.must_raise(Sequel::InvalidValue)
+    proc{@m.parse_json('a')}.must_raise(Sequel::InvalidValue)
 
     begin
       Sequel.instance_eval do

data/spec/integration/schema_test.rb

@@ -354,7 +354,7 @@ describe "Database schema modifiers" do
       @ds.select_order_map(:number).must_equal [1, 2, 2, 3, 4]
     end if DB.supports_views_with_local_check_option?
 
-    cspecify "should create views with explicit columns correctly", :sqlite do
+    cspecify "should create views with explicit columns correctly", [proc{|db| db.sqlite_version < 30900}, :sqlite] do
       @db.create_view(:items_view, @ds.where(:number=>1), :columns=>[:n])
       @db[:items_view].map(:n).must_equal [1]
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.36.0
+  version: 4.37.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-01 00:00:00.000000000 Z
+date: 2016-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -237,6 +237,7 @@ extra_rdoc_files:
 - doc/release_notes/4.34.0.txt
 - doc/release_notes/4.35.0.txt
 - doc/release_notes/4.36.0.txt
+- doc/release_notes/4.37.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -362,6 +363,7 @@ files:
 - doc/release_notes/4.34.0.txt
 - doc/release_notes/4.35.0.txt
 - doc/release_notes/4.36.0.txt
+- doc/release_notes/4.37.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
 - doc/release_notes/4.6.0.txt
@@ -424,7 +426,6 @@ files:
 - lib/sequel/adapters/shared/informix.rb
 - lib/sequel/adapters/shared/mssql.rb
 - lib/sequel/adapters/shared/mysql.rb
-- lib/sequel/adapters/shared/mysql_prepared_statements.rb
 - lib/sequel/adapters/shared/oracle.rb
 - lib/sequel/adapters/shared/postgres.rb
 - lib/sequel/adapters/shared/progress.rb
@@ -439,6 +440,8 @@ files:
 - lib/sequel/adapters/tinytds.rb
 - lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb
 - lib/sequel/adapters/utils/emulate_offset_with_row_number.rb
+- lib/sequel/adapters/utils/mysql_mysql2.rb
+- lib/sequel/adapters/utils/mysql_prepared_statements.rb
 - lib/sequel/adapters/utils/pg_types.rb
 - lib/sequel/adapters/utils/replace.rb
 - lib/sequel/adapters/utils/split_alter_table.rb