sequel 3.35.0 → 3.36.0

data/lib/sequel/adapters/mysql.rb

@@ -118,19 +118,13 @@ module Sequel
           Mysql::CLIENT_MULTI_STATEMENTS +
           (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
         )
-        sqls = []
+        sqls = mysql_connection_setting_sqls
+
         # Set encoding a slightly different way after connecting,
         # in case the READ_DEFAULT_GROUP overrode the provided encoding.
         # Doesn't work across implicit reconnects, but Sequel doesn't turn on
         # that feature.
-        sqls << "SET NAMES #{literal(encoding.to_s)}" if encoding
-
-        # Increase timeout so mysql server doesn't disconnect us
-        # Value used by default is maximum allowed value on Windows.
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
-
-        # By default, MySQL 'where id is null' selects the last inserted id
-        sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
+        sqls.unshift("SET NAMES #{literal(encoding.to_s)}") if encoding
 
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 

data/lib/sequel/adapters/mysql2.rb

@@ -10,7 +10,7 @@ module Sequel
       include Sequel::MySQL::PreparedStatements::DatabaseMethods
 
       # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(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|This connection is still waiting for a result, try again once you have the result)/
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(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|This connection is still waiting for a result, try again once you have the result|closed MySQL connection)/
 
       set_adapter_scheme :mysql2
       
@@ -48,22 +48,16 @@ module Sequel
         opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
 
-        sqls = []
+        sqls = mysql_connection_setting_sqls
+
         # Set encoding a slightly different way after connecting,
         # in case the READ_DEFAULT_GROUP overrode the provided encoding.
         # Doesn't work across implicit reconnects, but Sequel doesn't turn on
         # that feature.
         if encoding = opts[:encoding] || opts[:charset]
-          sqls << "SET NAMES #{conn.escape(encoding.to_s)}"
+          sqls.unshift("SET NAMES #{conn.escape(encoding.to_s)}")
         end
 
-        # Increase timeout so mysql server doesn't disconnect us.
-        # Value used by default is maximum allowed value on Windows.
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
-
-        # By default, MySQL 'where id is null' selects the last inserted id
-        sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
-
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
         add_prepared_statements_cache(conn)
@@ -113,8 +107,15 @@ module Sequel
         [::Mysql2::Error]
       end
 
+      # If a connection object is available, try pinging it.  Otherwise, if the
+      # error is a Mysql2::Error, check the SQL state and exception message for
+      # disconnects.
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::Mysql2::Error) && MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+        super ||
+          ((conn = opts[:conn]) && !conn.ping) ||
+          (e.is_a?(::Mysql2::Error) &&
+            (e.sql_state =~ /\A08/ ||
+             MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)))
       end
 
       # The database name when using the native adapter is always stored in

data/lib/sequel/adapters/postgres.rb

@@ -294,10 +294,7 @@ module Sequel
       
       # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts={}, &block)
-        check_database_errors do
-          return execute_prepared_statement(sql, opts, &block) if Symbol === sql
-          synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
-        end
+        synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
       end
 
       if SEQUEL_POSTGRES_USES_PG
@@ -436,6 +433,15 @@ module Sequel
         
       private
 
+      # Execute the given SQL string or prepared statement on the connection object.
+      def _execute(conn, sql, opts, &block)
+        if sql.is_a?(Symbol)
+          execute_prepared_statement(conn, sql, opts, &block)
+        else
+          conn.execute(sql, opts[:arguments], &block)
+        end
+      end
+
       # Convert exceptions raised from the block into DatabaseErrors.
       def check_database_errors
         begin
@@ -466,38 +472,34 @@ module Sequel
       # has prepared a statement with the same name and different SQL,
       # deallocate that statement first and then prepare this statement.
       # If a block is given, yield the result, otherwise, return the number
-      # of rows changed.  If the :insert option is passed, return the value
-      # of the primary key for the last inserted row.
-      def execute_prepared_statement(name, opts={})
+      # of rows changed.
+      def execute_prepared_statement(conn, name, opts={}, &block)
         ps = prepared_statement(name)
         sql = ps.prepared_sql
         ps_name = name.to_s
-        synchronize(opts[:server]) do |conn|
-          if args = opts[:arguments]
-            args = args.map{|arg| bound_variable_arg(arg, conn)}
-          end
 
-          unless conn.prepared_statements[ps_name] == sql
-            if conn.prepared_statements.include?(ps_name)
-              conn.execute("DEALLOCATE #{ps_name}") unless conn.prepared_statements[ps_name] == sql
-            end
-            conn.prepared_statements[ps_name] = sql
-            conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
-          end
+        if args = opts[:arguments]
+          args = args.map{|arg| bound_variable_arg(arg, conn)}
+        end
 
-          log_sql = "EXECUTE #{ps_name}"
-          if ps.log_sql
-            log_sql << " ("
-            log_sql << sql
-            log_sql << ")"
-          end
+        unless conn.prepared_statements[ps_name] == sql
+          conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
+          conn.prepared_statements[ps_name] = sql
+          conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
+        end
 
-          q = conn.check_disconnect_errors{log_yield(log_sql, args){conn.exec_prepared(ps_name, args)}}
-          begin
-            block_given? ? yield(q) : q.cmd_tuples
-          ensure
-            q.clear
-          end
+        log_sql = "EXECUTE #{ps_name}"
+        if ps.log_sql
+          log_sql << " ("
+          log_sql << sql
+          log_sql << ")"
+        end
+
+        q = conn.check_disconnect_errors{log_yield(log_sql, args){conn.exec_prepared(ps_name, args)}}
+        begin
+          block_given? ? yield(q) : q.cmd_tuples
+        ensure
+          q.clear
         end
       end
 
@@ -640,11 +642,6 @@ module Sequel
           def execute_dui(sql, opts={}, &block)
             super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
           end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_insert(sql, opts={}, &block)
-            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
         end
         
         # Allow use of server side prepared statements for PostgreSQL using the
@@ -670,11 +667,6 @@ module Sequel
           def execute_dui(sql, opts={}, &block)
             super(prepared_statement_name, opts, &block)
           end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_insert(sql, opts={}, &block)
-            super(prepared_statement_name, opts, &block)
-          end
         end
         
         # Execute the given type of statement with the hash of values.

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

@@ -28,6 +28,11 @@ module Sequel
         :mssql
       end
       
+      # Microsoft SQL Server namespaces indexes per table.
+      def global_index_namespace?
+        false
+      end
+
       # Use the system tables to get index information
       def indexes(table, opts={})
         m = output_identifier_meth
@@ -187,6 +192,16 @@ module Sequel
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
+      # support for clustered index type
+      def index_definition_sql(table_name, index)
+        index_name = index[:name] || default_index_name(table_name, index[:columns])
+        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])}#{" INCLUDE #{literal(index[:include])}" if index[:include]}#{" WHERE #{filter_expr(index[:where])}" if index[:where]}"
+        end
+      end
+
       # Backbone of the tables and views support.
       def information_schema_tables(type, opts)
         m = output_identifier_meth
@@ -290,17 +305,6 @@ module Sequel
       def type_literal_generic_file(column)
         :'varbinary(max)'
       end
-
-      # support for clustered index type
-      def index_definition_sql(table_name, index)
-        index_name = index[:name] || default_index_name(table_name, index[:columns])
-        raise Error, "Partial indexes are not supported for this database" if index[:where]
-        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])}#{" INCLUDE #{literal(index[:include])}" if index[:include]}"
-        end
-      end
     end
   
     module DatasetMethods

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

@@ -76,6 +76,11 @@ module Sequel
         h.values
       end
 
+      # MySQL namespaces indexes per table.
+      def global_index_namespace?
+        false
+      end
+
       # Use SHOW INDEX FROM to get the index information for the
       # table.
       #
@@ -124,10 +129,10 @@ module Sequel
         server_version >= 50000
       end
 
-      # MySQL doesn't appear to support savepoints inside prepared transactions in >=5.5.12,
-      # see http://bugs.mysql.com/bug.php?id=64374
+      # MySQL doesn't support savepoints inside prepared transactions in from
+      # 5.5.12 to 5.5.23, see http://bugs.mysql.com/bug.php?id=64374
       def supports_savepoints_in_prepared_transactions?
-        super && server_version <= 50512
+        super && (server_version <= 50512 || server_version >= 50523)
       end
 
       # MySQL supports transaction isolation levels
@@ -208,6 +213,26 @@ module Sequel
           super(table, op)
         end
       end
+
+      # The SQL queries to execute on initial connection
+      def mysql_connection_setting_sqls
+        sqls = []
+        
+        # Increase timeout so mysql server doesn't disconnect us
+        # Value used by default is maximum allowed value on Windows.
+        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
+
+        # By default, MySQL 'where id is null' selects the last inserted id
+        sqls <<  "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
+
+        # If the user has specified one or more sql modes, enable them
+        if sql_mode = opts[:sql_mode]
+          sql_mode = Array(sql_mode).join(',').upcase
+          sqls <<  "SET sql_mode = '#{sql_mode}'"
+        end
+
+        sqls
+      end
       
       # Use MySQL specific AUTO_INCREMENT text.
       def auto_increment_sql

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

@@ -29,6 +29,11 @@ module Sequel
         :oracle
       end
 
+      # Oracle namespaces indexes per table.
+      def global_index_namespace?
+        false
+      end
+
       def tables(opts={})
         m = output_identifier_meth
         metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE').map{|r| m.call(r[:tname])}

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

@@ -247,9 +247,9 @@ module Sequel
         # If a schema is given, we only search in that schema, and the returned :table
         # entry is schema qualified as well.
         if schema
-          ds.join!(:pg_namespace___nsp, :oid=>:cl__relnamespace).
-            where(:nsp___nspname=>im.call(schema))
-          ref_ds.join!(:pg_namespace___nsp2, :oid=>:cl2__relnamespace).
+          ds = ds.join(:pg_namespace___nsp, :oid=>:cl__relnamespace).
+            where(:nsp__nspname=>im.call(schema))
+          ref_ds = ref_ds.join(:pg_namespace___nsp2, :oid=>:cl2__relnamespace).
             select_more(:nsp2__nspname___schema)
         end
 
@@ -264,7 +264,7 @@ module Sequel
         end
         ref_ds.each do |row|
           r = h[row[:name]]
-          r[:table] ||= m.call(schema ? SQL::QualifiedIdentifier.new(row[:schema], row[:table]) : row[:table])
+          r[:table] ||= schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table])
           r[:key] ||= []
           r[:key] << m.call(row[:refcolumn])
         end
@@ -444,6 +444,41 @@ module Sequel
 
       private
 
+      # Handle :using option for set_column_type op.
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :set_column_type
+          s = super
+          if using = op[:using]
+            using = Sequel::LiteralString.new(using) if using.is_a?(String)
+            s << ' USING '
+            s << literal(using)
+          end
+          s
+        else
+          super
+        end
+      end
+
+      # If the :synchronous option is given and non-nil, set synchronous_commit
+      # appropriately.  Valid values for the :synchronous option are true,
+      # :on, false, :off, :local, and :remote_write.
+      def begin_new_transaction(conn, opts)
+        super
+        if opts.has_key?(:synchronous)
+          case sync = opts[:synchronous]
+          when true
+            sync = :on
+          when false
+            sync = :off
+          when nil
+            return
+          end
+
+          log_connection_execute(conn, "SET LOCAL synchronous_commit = #{sync}")
+        end
+      end
+      
       # If the :prepare option is given and we aren't in a savepoint,
       # prepare the transaction for a two-phase commit.
       def commit_transaction(conn, opts={})
@@ -511,6 +546,11 @@ module Sequel
       def drop_function_sql(name, opts={})
         "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
       end
+      
+      # Support :if_exists, :cascade, and :concurrently options.
+      def drop_index_sql(table, op)
+        "DROP INDEX#{' CONCURRENTLY' if op[:concurrently]}#{' IF EXISTS' if op[:if_exists]} #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))}#{' CASCADE' if op[:cascade]}"
+      end
 
       # SQL for dropping a procedural language from the database.
       def drop_language_sql(name, opts={})
@@ -567,7 +607,7 @@ module Sequel
         when :spatial
           index_type = :gist
         end
-        "CREATE #{unique}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
+        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
       end
 
       # Backbone of the tables and views support.
@@ -642,6 +682,20 @@ module Sequel
         end
       end
 
+      # Set the transaction isolation level on the given connection
+      def set_transaction_isolation(conn, opts)
+        level = opts.fetch(:isolation, transaction_isolation_level)
+        read_only = opts[:read_only]
+        deferrable = opts[:deferrable]
+        if level || !read_only.nil? || !deferrable.nil?
+          sql = "SET TRANSACTION"
+          sql << " ISOLATION LEVEL #{Sequel::Database::TRANSACTION_ISOLATION_LEVELS[level]}" if level
+          sql << " READ #{read_only ? 'ONLY' : 'WRITE'}" unless read_only.nil?
+          sql << " #{'NOT ' unless deferrable}DEFERRABLE" unless deferrable.nil?
+          log_connection_execute(conn, sql)
+        end
+      end
+     
       # Turns an array of argument specifiers into an SQL fragment used for function arguments.  See create_function_sql.
       def sql_function_args(args)
         "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"

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

@@ -28,12 +28,6 @@ module Sequel
         pragma_set(:auto_vacuum, value)
       end
 
-      # Boolean signifying the value of the case_sensitive_likePRAGMA, or nil
-      # if not using SQLite 3.2.3+.
-      def case_sensitive_like
-        pragma_get(:case_sensitive_like).to_i == 1 if sqlite_version >= 30203
-      end
-      
       # Set the case_sensitive_like PRAGMA using the given boolean value, if using
       # SQLite 3.2.3+.  If not using 3.2.3+, no error is raised. See pragma_set.
       # Consider using the :case_sensitive_like Database option instead.
@@ -252,7 +246,7 @@ module Sequel
         end
       end
 
-      # The array of column symbols in the table, except for ones given in opts[:except]
+      # A name to use for the backup table
       def backup_table_name(table, opts={})
         table = table.gsub('`', '')
         (opts[:times]||1000).times do |i|
@@ -283,17 +277,13 @@ module Sequel
         ps
       end
 
-      # The array of column schema hashes, except for the ones given in opts[:except]
-      def defined_columns_for(table, opts={})
+      # The array of column schema hashes for the current columns in the table
+      def defined_columns_for(table)
         cols = parse_pragma(table, {})
         cols.each do |c|
           c[:default] = LiteralString.new(c[:default]) if c[:default]
           c[:type] = c[:db_type]
         end
-        if opts[:except]
-          nono= Array(opts[:except]).compact.map{|n| n.to_s}
-          cols.reject!{|c| nono.include? c[:name] }
-        end
         cols
       end
 

data/lib/sequel/adapters/sqlite.rb

@@ -144,11 +144,6 @@ module Sequel
         _execute(:insert, sql, opts)
       end
       
-      # Run the given SQL with the given arguments and return the first value of the first row.
-      def single_value(sql, opts={})
-        _execute(:single_value, sql, opts)
-      end
-      
       # Handle Integer and Float arguments, since SQLite can store timestamps as integers and floats.
       def to_application_timestamp(s)
         case s
@@ -177,8 +172,6 @@ module Sequel
             case type
             when :select
               log_yield(sql, log_args){conn.query(sql, args, &block)}
-            when :single_value
-              log_yield(sql, log_args){conn.get_first_value(sql, args)}
             when :insert
               log_yield(sql, log_args){conn.execute(sql, args)}
               conn.last_insert_row_id