sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/tinytds.rb

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 require 'tiny_tds'
-Sequel.require 'adapters/shared/mssql'
+require_relative 'shared/mssql'
 
 module Sequel
   module TinyTDS
@@ -14,9 +16,22 @@ module Sequel
         c = TinyTds::Client.new(opts)
         c.query_options.merge!(:cache_rows=>false)
 
+        # SEQUEL6: Default to ansi: true
+        if opts[:ansi]
+          sql = %w(
+            ANSI_NULLS
+            ANSI_PADDING
+            ANSI_WARNINGS
+            ANSI_NULL_DFLT_ON
+            QUOTED_IDENTIFIER
+            CONCAT_NULL_YIELDS_NULL
+          ).map{|v| "SET #{v} ON"}.join(";")
+          log_connection_yield(sql, c){c.execute(sql)}
+        end
+
         if (ts = opts[:textsize])
           sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
-          log_yield(sql){c.execute(sql)}
+          log_connection_yield(sql, c){c.execute(sql)}
         end
       
         c
@@ -50,14 +65,14 @@ module Sequel
                 single_value = true
               end
               sql = "EXEC sp_executesql N'#{c.escape(sql)}', N'#{c.escape(types.join(', '))}', #{values.join(', ')}"
-              log_yield(sql) do
+              log_connection_yield(sql, c) do
                 r = c.execute(sql)
                 r.each{|row| return row.values.first} if single_value
               end
             else
-              log_yield(sql) do
+              log_connection_yield(sql, c) do
                 r = c.execute(sql)
-                return r.send(m) if m
+                return r.public_send(m) if m
               end
             end
             yield(r) if block_given?
@@ -69,22 +84,18 @@ module Sequel
         end
       end
 
-      # Return the number of rows modified by the given +sql+.
       def execute_dui(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:return] = :do
         execute(sql, opts)
       end
 
-      # Return the value of the autogenerated primary key (if any)
-      # for the row inserted by the given +sql+.
       def execute_insert(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:return] = :insert
         execute(sql, opts)
       end
 
-      # Execute the DDL +sql+ on the database and return nil.
       def execute_ddl(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:return] = :each
@@ -129,24 +140,25 @@ module Sequel
         end
       end
 
-      TINYTDS_DISCONNECT_ERRORS = /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client)/
+      def dataset_class_default
+        Dataset
+      end
+
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
-        super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && TINYTDS_DISCONNECT_ERRORS.match(e.message)))
+        super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client|Adaptive Server connection timed out|DBPROCESS is dead or not enabled)/.match(e.message)))
       end
 
       # Dispose of any possible results of execution.
       def log_connection_execute(conn, sql)
-        log_yield(sql){conn.execute(sql).each}
+        log_connection_yield(sql, conn){conn.execute(sql).each}
       end
 
       # Return a 2 element array with the literal value and type to use
       # in the prepared statement call for the given value and connection.
       def ps_arg_type(v)
         case v
-        when Fixnum
-          [v, 'int']
-        when Bignum
+        when Integer
           [v, 'bigint']
         when Float
           [v, 'double precision']
@@ -179,16 +191,11 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
 
-      Database::DatasetClass = self
-      
-      # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
         protected
         
-        # Return a hash with the same values as the given hash,
-        # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
           hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
@@ -197,24 +204,17 @@ module Sequel
         
         private
         
-        # SQLite uses a : before the name of the argument for named
-        # arguments.
         def prepared_arg(k)
           LiteralString.new("@#{k.to_s.gsub('.', '__')}")
         end
-
-        # Always assume a prepared argument.
-        def prepared_arg?(k)
-          true
-        end
       end
       
       PreparedStatementMethods = prepared_statements_module("sql = prepared_sql; opts = Hash[opts]; opts[:arguments] = bind_arguments", ArgumentMapper)
     
-      # Yield hashes with symbol keys, attempting to optimize for
-      # various cases.
       def fetch_rows(sql)
         execute(sql) do |result|
+          # Mutating an array in the result is questionable, but supported
+          # by tiny_tds developers (tiny_tds issue #57)
           columns = result.fields.map!{|c| output_identifier(c)}
           if columns.empty?
             args = []
@@ -223,7 +223,7 @@ module Sequel
             result.each(*args) do |r|
               unless cols
                 cols = result.fields.map{|c| [c, output_identifier(c)]}
-                @columns = columns = cols.map(&:last)
+                self.columns = columns = cols.map(&:last)
               end
               h = {}
               cols.each do |s, sym|
@@ -232,7 +232,7 @@ module Sequel
               yield h
             end
           else
-            @columns = columns
+            self.columns = columns
             if db.timezone == :utc
               result.each(:timezone=>:utc){|r| yield r}
             else
@@ -243,24 +243,16 @@ module Sequel
         self
       end
       
-      # 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
-      
       private
       
-      # Properly escape the given string +v+.
+      # Properly escape the given string
       def literal_string_append(sql, v)
-        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
-        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
+        sql << (mssql_unicode_strings ? "N'" : "'")
+        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(/\\((?:\r\n)|\n)/, '\\\\\\\\\\1\\1') << "'"
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module EmulateOffsetWithReverseAndCount
     # Make empty? work with an offset with an order.
@@ -27,23 +29,20 @@ module Sequel
       end
 
       ds = unlimited
-      row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>'', :placeholder_literal_null=>true).count
+      row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>String.new, :placeholder_literal_null=>true).count
       dsa1 = dataset_alias(1)
 
-      if o.is_a?(Symbol) && @opts[:bind_vars] && (match = Sequel::Dataset::PreparedStatementMethods::PLACEHOLDER_RE.match(o.to_s))
+      if o.is_a?(Symbol) && @opts[:bind_vars] && /\A\$(.*)\z/ =~ o
         # Handle use of bound variable offsets.  Unfortunately, prepared statement
         # bound variable offsets cannot be handled, since the bound variable value
         # isn't available until later.
-        s = match[1].to_sym
-        if prepared_arg?(s)
-          o = prepared_arg(s)
-        end
+        o = prepared_arg($1.to_sym)
       end
 
       reverse_offset = row_count - o
       ds = if reverse_offset > 0
         ds.limit(reverse_offset).
-          reverse_order(*order).
+          reverse(*order).
           from_self(:alias=>dsa1).
           limit(@opts[:limit]).
           order(*order)
@@ -53,7 +52,7 @@ module Sequel
         # shuld be returned, so use a condition that is always false.
         ds.where(1=>0)
       end
-      sql = @opts[:append_sql] || ''
+      sql = @opts[:append_sql] || String.new
       subselect_sql_append(sql, ds)
       sql
     end
@@ -69,7 +68,7 @@ module Sequel
     # The default order to use for datasets with offsets, if no order is defined.
     # By default, orders by all of the columns in the dataset.
     def default_offset_order
-      clone(:append_sql=>'', :offset=>nil).columns
+      clone(:append_sql=>String.new, :offset=>nil).columns
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module EmulateOffsetWithRowNumber
     # If the offset must be emulated with ROW_NUMBER, don't remove any ordering,
@@ -5,7 +7,7 @@ module Sequel
     # when ordering.
     def empty?
       return super unless emulate_offset_with_row_number?
-      get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
+      select(Dataset::EMPTY_SELECT).limit(1).single_value!.nil?
     end
 
     # Emulate OFFSET support with the ROW_NUMBER window function
@@ -28,13 +30,13 @@ module Sequel
         end
       end
 
-      columns = clone(:append_sql=>'', :placeholder_literal_null=>true).columns
+      columns = clone(:append_sql=>String.new, :placeholder_literal_null=>true).columns
       dsa1 = dataset_alias(1)
       rn = row_number_column
-      sql = @opts[:append_sql] || ''
+      sql = @opts[:append_sql] || String.new
       subselect_sql_append(sql, unlimited.
         unordered.
-        select_append{ROW_NUMBER{}.over(:order=>order).as(rn)}.
+        select_append(Sequel.function(:ROW_NUMBER).over(:order=>order).as(rn)).
         from_self(:alias=>dsa1).
         select(*columns).
         limit(@opts[:limit]).
@@ -75,7 +77,7 @@ module Sequel
           end
         end
       end
-      clone(:append_sql=>'').columns
+      clone(:append_sql=>String.new).columns
     end
 
     # Whether an order is required when using offset emulation via ROW_NUMBER, true by default.

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

@@ -0,0 +1,87 @@
+# frozen-string-literal: true
+
+require_relative '../shared/mysql'
+require_relative 'stored_procedures'
+
+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
+        MySQL client is not connected
+        This connection is still waiting for a result, try again once you have the result
+        closed MySQL connection
+        The MySQL server is running with the --read-only option so it cannot execute this statement
+        Connection was killed
+        END
+        # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/
+       
+        # 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
+
+        def database_specific_error_class(exception, opts)
+          case exception.errno
+          when 1048
+            NotNullConstraintViolation
+          when 1062
+            UniqueConstraintViolation
+          when 1451, 1452, 1216, 1217
+            ForeignKeyConstraintViolation
+          when 4025
+            CheckConstraintViolation
+          when 1205
+            DatabaseLockTimeout
+          else
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        include Sequel::Dataset::StoredProcedures
+       
+        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
+          "sql = @opts[:sproc_name]; opts = Hash[opts]; opts[:args] = @opts[: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.with_extend(StoredProcedureMethods)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen-string-literal: true
+
+module Sequel
+  module MySQL
+    module PreparedStatements
+      module DatabaseMethods
+        private
+
+        # 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.  Issue a SET
+        # query with literalized values for each argument, then an EXECUTE to
+        # execute the query with the arguments.
+        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|
+            unless conn.prepared_statements[ps_name] == sql
+              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+              conn.prepared_statements[ps_name] = sql
+            end
+            i = 0
+            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
+            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        module CallableStatementMethods
+          # Extend given dataset with this module so subselects inside subselects in
+          # prepared statements work.
+          def subselect_sql_append(sql, ds)
+            ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+              send(:to_prepared_statement, :select, nil, :extend=>bound_variable_modules).
+              prepared_sql
+          end
+        end
+        
+        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, Sequel::Dataset::UnnumberedArgumentMapper)
+        
+        private
+
+        def bound_variable_modules
+          [CallableStatementMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,8 @@
+# frozen-string-literal: true
+
 module Sequel
   class Dataset
     module Replace
-      INSERT = Dataset::INSERT
-      REPLACE = 'REPLACE'.freeze
-
       # Execute a REPLACE statement on the database (deletes any duplicate
       # rows before inserting).
       def replace(*values)
@@ -29,7 +28,7 @@ module Sequel
 
       # If this is an replace instead of an insert, use replace instead
       def insert_insert_sql(sql)
-        sql << (@opts[:replace] ? REPLACE : INSERT)
+        sql << (@opts[:replace] ? 'REPLACE' : 'INSERT')
       end
     end
   end