sequel 5.48.0 → 5.52.0

data/lib/sequel/adapters/mysql.rb

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 require 'mysql'
-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)
+raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!, so it not supported. Please install the mysql or ruby-mysql gem.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
 require_relative 'utils/mysql_mysql2'
 require_relative 'utils/mysql_prepared_statements'
@@ -71,21 +71,43 @@ module Sequel
       #             disconnect this connection (a.k.a @@wait_timeout).
       def connect(server)
         opts = server_opts(server)
-        conn = Mysql.init
-        conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
-        conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
-        conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]
-        if encoding = opts[:encoding] || opts[:charset]
-          # Set encoding before connecting so that the mysql driver knows what
-          # encoding we want to use, but this can be overridden by READ_DEFAULT_GROUP.
-          conn.options(Mysql::SET_CHARSET_NAME, encoding)
-        end
-        if read_timeout = opts[:read_timeout] and defined? Mysql::OPT_READ_TIMEOUT
-          conn.options(Mysql::OPT_READ_TIMEOUT, read_timeout)
-        end
-        if connect_timeout = opts[:connect_timeout] and defined? Mysql::OPT_CONNECT_TIMEOUT
-          conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
+
+        if Mysql.respond_to?(:init)
+          conn = Mysql.init
+          conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
+          conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
+          if encoding = opts[:encoding] || opts[:charset]
+            # Set encoding before connecting so that the mysql driver knows what
+            # encoding we want to use, but this can be overridden by READ_DEFAULT_GROUP.
+            conn.options(Mysql::SET_CHARSET_NAME, encoding)
+          end
+          if read_timeout = opts[:read_timeout] and defined? Mysql::OPT_READ_TIMEOUT
+            conn.options(Mysql::OPT_READ_TIMEOUT, read_timeout)
+          end
+          if connect_timeout = opts[:connect_timeout] and defined? Mysql::OPT_CONNECT_TIMEOUT
+            conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
+          end
+        else
+          # ruby-mysql 3 API
+          conn = Mysql.new
+          # no support for default group
+          conn.local_infile = opts[:config_local_infile] if opts.has_key?(:config_local_infile)
+          if encoding = opts[:encoding] || opts[:charset]
+            conn.charset = encoding
+          end
+          if read_timeout = opts[:read_timeout]
+            conn.read_timeout = read_timeout
+          end
+          if connect_timeout = opts[:connect_timeout]
+            conn.connect_timeout = connect_timeout
+          end
+          conn.singleton_class.class_eval do
+            alias real_connect connect
+            alias use_result store_result
+          end
         end
+
+        conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]
         conn.real_connect(
           opts[:host] || 'localhost',
           opts[:user],
@@ -152,56 +174,49 @@ module Sequel
         super
       end
 
-      # Return the version of the MySQL server to which we are connecting.
-      def server_version(server=nil)
-        @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
-      end
-
       private
       
       # 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
-          r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn){conn.query(sql)}
-          if opts[:type] == :select
-            yield r if r
-          elsif block_given?
-            yield conn
-          end
-          if conn.respond_to?(:more_results?)
-            while conn.more_results? do
-              if r
-                r.free
-                r = nil
-              end
-              begin
-                conn.next_result
-                r = conn.use_result
-              rescue Mysql::Error => e
-                raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
-                break
-              end
-              yield r if opts[:type] == :select
+        r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn){conn.query(sql)}
+        if opts[:type] == :select
+          yield r if r
+        elsif defined?(yield)
+          yield conn
+        end
+        if conn.respond_to?(:more_results?)
+          while conn.more_results? do
+            if r
+              r.free
+              r = nil
+            end
+            begin
+              conn.next_result
+              r = conn.use_result
+            rescue Mysql::Error => e
+              raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
+              break
             end
+            yield r if opts[:type] == :select
           end
-        rescue Mysql::Error => e
-          raise_error(e)
-        ensure
-          r.free if r
-          # Use up all results to avoid a commands out of sync message.
-          if conn.respond_to?(:more_results?)
-            while conn.more_results? do
-              begin
-                conn.next_result
-                r = conn.use_result
-              rescue Mysql::Error => e
-                raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
-                break
-              end
-              r.free if r
+        end
+      rescue Mysql::Error => e
+        raise_error(e)
+      ensure
+        r.free if r
+        # Use up all results to avoid a commands out of sync message.
+        if conn.respond_to?(:more_results?)
+          while conn.more_results? do
+            begin
+              conn.next_result
+              r = conn.use_result
+            rescue Mysql::Error => e
+              raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
+              break
             end
+            r.free if r
           end
         end
       end
@@ -233,17 +248,15 @@ module Sequel
       # the conversion raises an InvalidValue exception, return v
       # if :string and nil otherwise.
       def convert_date_time(v)
-        begin
-          yield v
-        rescue InvalidValue
-          case @convert_invalid_date_time
-          when nil, :nil
-            nil
-          when :string
-            v
-          else 
-            raise
-          end
+        yield v
+      rescue InvalidValue
+        case @convert_invalid_date_time
+        when nil, :nil
+          nil
+        when :string
+          v
+        else 
+          raise
         end
       end
     

data/lib/sequel/adapters/mysql2.rb

@@ -111,56 +111,54 @@ module Sequel
       # 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]
-          if NativePreparedStatements
-            if args = opts[:arguments]
-              args = args.map{|arg| bound_variable_value(arg)}
-            end
+        stream = opts[: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
+          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
+        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
-          if opts[:type] == :select
-            if r
-              if stream
-                begin
-                  r2 = yield r
-                ensure
-                  # If r2 is nil, it means the block did not exit normally,
-                  # so the rest of the results must be drained to prevent
-                  # "commands out of sync" errors.
-                  r.each{} unless r2
-                end
-              else
-                yield r
+        end
+        if opts[:type] == :select
+          if r
+            if stream
+              begin
+                r2 = yield r
+              ensure
+                # If r2 is nil, it means the block did not exit normally,
+                # so the rest of the results must be drained to prevent
+                # "commands out of sync" errors.
+                r.each{} unless r2
               end
+            else
+              yield r
             end
-          elsif block_given?
-            yield conn
-          end
-        rescue ::Mysql2::Error => e
-          raise_error(e)
-        ensure
-          if stmt
-            conn.query_options.replace(conn.instance_variable_get(:@sequel_default_query_options))
-            stmt.close if close_stmt
           end
+        elsif defined?(yield)
+          yield conn
+        end
+      rescue ::Mysql2::Error => e
+        raise_error(e)
+      ensure
+        if stmt
+          conn.query_options.replace(conn.instance_variable_get(:@sequel_default_query_options))
+          stmt.close if close_stmt
         end
       end
 
@@ -244,7 +242,7 @@ module Sequel
       # it hasn't been disabled.
       def paged_each(opts=OPTS, &block)
         if STREAMING_SUPPORTED && opts[:stream] != false
-          unless block_given?
+          unless defined?(yield)
             return enum_for(:paged_each, opts)
           end
           stream.each(&block)

data/lib/sequel/adapters/odbc.rb

@@ -40,7 +40,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             r = log_connection_yield(sql, conn){conn.run(sql)}
-            yield(r) if block_given?
+            yield(r) if defined?(yield)
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           ensure

data/lib/sequel/adapters/oracle.rb

@@ -88,11 +88,11 @@ module Sequel
               r = conn.parse(sql)
               args = cursor_bind_params(conn, r, args)
               nr = log_connection_yield(sql, conn, args){r.exec}
-              r = nr unless block_given?
+              r = nr unless defined?(yield)
             else
               r = log_connection_yield(sql, conn){conn.exec(sql)}
             end
-            if block_given?
+            if defined?(yield)
               yield(r)
             elsif type == :insert
               last_insert_id(conn, opts)
@@ -192,7 +192,7 @@ module Sequel
           log_sql << ")"
         end
         r = log_connection_yield(log_sql, conn, args){cursor.exec}
-        if block_given?
+        if defined?(yield)
           yield(cursor)
         elsif type == :insert
           last_insert_id(conn, opts)

data/lib/sequel/adapters/postgres.rb

@@ -116,25 +116,23 @@ module Sequel
       # error classes is raised, or a PGError is raised and the connection
       # status cannot be determined or it is not OK.
       def check_disconnect_errors
+        yield
+      rescue *DISCONNECT_ERROR_CLASSES => e
+        disconnect = true
+        raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
+      rescue PGError => e
+        disconnect = false
         begin
-          yield
-        rescue *DISCONNECT_ERROR_CLASSES => e
+          s = status
+        rescue PGError
           disconnect = true
-          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
-        rescue PGError => e
-          disconnect = false
-          begin
-            s = status
-          rescue PGError
-            disconnect = true
-          end
-          status_ok = (s == Adapter::CONNECTION_OK)
-          disconnect ||= !status_ok
-          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
-          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
-        ensure
-          block if status_ok && !disconnect
         end
+        status_ok = (s == Adapter::CONNECTION_OK)
+        disconnect ||= !status_ok
+        disconnect ||= e.message =~ DISCONNECT_ERROR_RE
+        disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
+      ensure
+        block if status_ok && !disconnect
       end
 
       # Execute the given SQL with this connection.  If a block is given,
@@ -143,7 +141,7 @@ module Sequel
         args = args.map{|v| @db.bound_variable_arg(v, self)} if args
         q = check_disconnect_errors{execute_query(sql, args)}
         begin
-          block_given? ? yield(q) : q.cmd_tuples
+          defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
           q.clear if q && q.respond_to?(:clear)
         end
@@ -350,7 +348,7 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             conn.execute(copy_table_sql(table, opts))
             begin
-              if block_given?
+              if defined?(yield)
                 while buf = conn.get_copy_data
                   yield buf
                 end
@@ -400,16 +398,16 @@ module Sequel
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
-          if block_given? && data
+          if defined?(yield) && data
             raise Error, "Cannot provide both a :data option and a block to copy_into"
-          elsif !block_given? && !data
+          elsif !defined?(yield) && !data
             raise Error, "Must provide either a :data option or a block to copy_into"
           end
 
           synchronize(opts[:server]) do |conn|
             conn.execute(copy_into_sql(table, opts))
             begin
-              if block_given?
+              if defined?(yield)
                 while buf = yield
                   conn.put_copy_data(buf)
                 end
@@ -518,11 +516,9 @@ module Sequel
 
       # Convert exceptions raised from the block into DatabaseErrors.
       def check_database_errors
-        begin
-          yield
-        rescue => e
-          raise_error(e, :classes=>database_error_classes)
-        end
+        yield
+      rescue => e
+        raise_error(e, :classes=>database_error_classes)
       end
 
       # Set the DateStyle to ISO if configured, for faster date parsing.
@@ -590,7 +586,7 @@ module Sequel
 
         q = conn.check_disconnect_errors{log_connection_yield(log_sql, conn, args){_execute_prepared_statement(conn, ps_name, args, opts)}}
         begin
-          block_given? ? yield(q) : q.cmd_tuples
+          defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
           q.clear if q && q.respond_to?(:clear)
         end
@@ -616,7 +612,7 @@ module Sequel
       
       # Use a cursor for paging.
       def paged_each(opts=OPTS, &block)
-        unless block_given?
+        unless defined?(yield)
           return enum_for(:paged_each, opts)
         end
         use_cursor(opts).each(&block)
@@ -717,7 +713,9 @@ module Sequel
         sql = String.new
         sql << "CALL "
         identifier_append(sql, name)
-        literal_append(sql, args)
+        sql << "("
+        expression_list_append(sql, args)
+        sql << ")"
         with_sql_first(sql)
       end
 

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

@@ -2,6 +2,7 @@
 
 require_relative '../utils/emulate_offset_with_reverse_and_count'
 require_relative '../utils/unmodified_identifiers'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module Access
@@ -83,6 +84,7 @@ module Sequel
       end)
       include EmulateOffsetWithReverseAndCount
       include UnmodifiedIdentifiers::DatasetMethods
+      include ::Sequel::Dataset::ColumnsLimit1
 
       EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}.freeze
       EXTRACT_MAP.each_value(&:freeze)

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

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
 require_relative '../utils/emulate_offset_with_row_number'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module DB2
@@ -273,6 +274,7 @@ module Sequel
 
     module DatasetMethods
       include EmulateOffsetWithRowNumber
+      include ::Sequel::Dataset::ColumnsLimit1
 
       BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}.freeze
 

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

@@ -533,6 +533,7 @@ module Sequel
           row[:default] = row.delete(:Default)
           row[:db_type] = row.delete(:Type)
           row[:type] = schema_column_type(row[:db_type])
+          row[:extra] = extra
           [m.call(row.delete(:Field)), row]
         end
       end
@@ -543,9 +544,10 @@ module Sequel
         server_version >= 50600 && (op[:op] == :drop_index || (op[:op] == :drop_constraint && op[:type] == :unique))
       end
 
-      # Whether the database supports CHECK constraints
+      # CHECK constraints only supported on MariaDB 10.2+ and MySQL 8.0.19+
+      # (at least MySQL documents DROP CONSTRAINT was supported in 8.0.19+).
       def supports_check_constraints?
-        mariadb? && server_version >= 100200
+        server_version >= (mariadb? ? 100200 : 80019)
       end
 
       # MySQL can combine multiple alter table ops into a single query.

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

@@ -87,7 +87,7 @@ module Sequel
 
     def self.mock_adapter_setup(db)
       db.instance_exec do
-        @server_version = 90500
+        @server_version = 140000
         initialize_postgres_adapter
         extend(MockAdapterDatabaseMethods)
       end
@@ -479,6 +479,7 @@ module Sequel
       #         :each_row :: Calls the trigger for each row instead of for each statement.
       #         :events :: Can be :insert, :update, :delete, or an array of any of those. Calls the trigger whenever that type of statement is used.  By default,
       #                    the trigger is called for insert, update, or delete.
+      #         :replace :: Replace the trigger with the same name if it already exists (PostgreSQL 14+).
       #         :when :: A filter to use for the trigger
       def create_trigger(table, name, function, opts=OPTS)
         self << create_trigger_sql(table, name, function, opts)
@@ -1237,7 +1238,7 @@ module Sequel
           raise Error, "Trigger conditions are not supported for this database" unless supports_trigger_conditions?
           filter = " WHEN #{filter_expr(filter)}"
         end
-        "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]}#{filter} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
+        "CREATE #{'OR REPLACE ' if opts[:replace]}TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]}#{filter} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
       end
 
       # DDL fragment for initial part of CREATE VIEW statement
@@ -1335,7 +1336,7 @@ module Sequel
         ds = metadata_dataset.from(:pg_class).where(:relkind=>type).select(:relname).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
         ds = filter_schema(ds, opts)
         m = output_identifier_meth
-        if block_given?
+        if defined?(yield)
           yield(ds)
         elsif opts[:qualify]
           ds.select_append{pg_namespace[:nspname]}.map{|r| Sequel.qualify(m.call(r[:nspname]).to_s, m.call(r[:relname]).to_s)}
@@ -1503,9 +1504,9 @@ module Sequel
         if column[:text]
           :text
         elsif column[:fixed]
-          "char(#{column[:size]||255})"
+          "char(#{column[:size]||default_string_column_size})"
         elsif column[:text] == false || column[:size]
-          "varchar(#{column[:size]||255})"
+          "varchar(#{column[:size]||default_string_column_size})"
         else
           :text
         end
@@ -1727,13 +1728,22 @@ module Sequel
         ds.insert_sql(*values)
       end
 
+      # Support SQL::AliasedExpression as expr to setup a USING join with a table alias for the
+      # USING columns.
+      def join_table(type, table, expr=nil, options=OPTS, &block)
+        if expr.is_a?(SQL::AliasedExpression) && expr.expression.is_a?(Array) && !expr.expression.empty? && expr.expression.all?
+          options = options.merge(:join_using=>true)
+        end
+        super
+      end
+
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with
       # the specified mode (e.g. 'EXCLUSIVE').  If a block is given, starts
       # a new transaction, locks the table, and yields.  If a block is not given,
       # just locks the tables.  Note that PostgreSQL will probably raise an error
       # if you lock the table outside of an existing transaction.  Returns nil.
       def lock(mode, opts=OPTS)
-        if block_given? # perform locking inside a transaction and yield to block
+        if defined?(yield) # perform locking inside a transaction and yield to block
           @db.transaction(opts){lock(mode, opts); yield}
         else
           sql = 'LOCK TABLE '.dup
@@ -2023,6 +2033,17 @@ module Sequel
         end
       end
 
+      # Support table aliases for USING columns
+      def join_using_clause_using_sql_append(sql, using_columns)
+        if using_columns.is_a?(SQL::AliasedExpression)
+          super(sql, using_columns.expression)
+          sql << ' AS '
+          identifier_append(sql, using_columns.alias)
+        else
+          super
+        end
+      end
+    
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
       def literal_blob_append(sql, v)
         sql << "'" << v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << "'"
@@ -2141,6 +2162,38 @@ module Sequel
         opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
       end
 
+      # Support PostgreSQL 14+ CTE SEARCH/CYCLE clauses
+      def select_with_sql_cte(sql, cte)
+        super
+
+        if search_opts = cte[:search]
+          sql << if search_opts[:type] == :breadth
+            " SEARCH BREADTH FIRST BY "
+          else
+            " SEARCH DEPTH FIRST BY "
+          end
+
+          identifier_list_append(sql, Array(search_opts[:by]))
+          sql << " SET "
+          identifier_append(sql, search_opts[:set] || :ordercol)
+        end
+
+        if cycle_opts = cte[:cycle]
+          sql << " CYCLE "
+          identifier_list_append(sql, Array(cycle_opts[:columns]))
+          sql << " SET "
+          identifier_append(sql, cycle_opts[:cycle_column] || :is_cycle)
+          if cycle_opts.has_key?(:cycle_value)
+            sql << " TO "
+            literal_append(sql, cycle_opts[:cycle_value])
+            sql << " DEFAULT "
+            literal_append(sql, cycle_opts.fetch(:noncycle_value, false))
+          end
+          sql << " USING "
+          identifier_append(sql, cycle_opts[:path_column] || :path)
+        end
+      end
+
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])

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

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require_relative '../utils/columns_limit_1'
+
 module Sequel
   module SqlAnywhere
     Sequel::Database.set_shared_adapter_scheme(:sqlanywhere, self)
@@ -234,6 +236,7 @@ module Sequel
     module DatasetMethods
       Dataset.def_sql_method(self, :insert, %w'insert into columns values')
       Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having window compounds order lock')
+      include ::Sequel::Dataset::ColumnsLimit1
 
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the IBMDB module setting.

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

@@ -393,7 +393,7 @@ module Sequel
         old_columns = def_columns.map{|c| c[:name]}
         opts[:old_columns_proc].call(old_columns) if opts[:old_columns_proc]
 
-        yield def_columns if block_given?
+        yield def_columns if defined?(yield)
 
         constraints = (opts[:constraints] || []).dup
         pks = []

data/lib/sequel/adapters/sqlanywhere.rb

@@ -120,7 +120,7 @@ module Sequel
 
         case type
         when :select
-          yield rs if block_given?
+          yield rs if defined?(yield)
         when :rows
           return @api.sqlany_affected_rows(rs)
         when :insert