sequel 3.37.0 → 3.38.0

data/lib/sequel/sql.rb

@@ -217,7 +217,7 @@ module Sequel
     module AliasMethods
       # Create an SQL alias (+AliasedExpression+) of the receiving column or expression to the given alias.
       #
-      #   :column.as(:alias) # "column" AS "alias"
+      #   Sequel.function(:func).as(:alias) # func() AS "alias"
       def as(aliaz)
         AliasedExpression.new(self, aliaz)
       end
@@ -389,6 +389,20 @@ module Sequel
         end
 
         case arg
+        when Symbol
+          t, c, a = Sequel.split_symbol(arg)
+
+          arg = if t
+            SQL::QualifiedIdentifier.new(t, c)
+          else
+            SQL::Identifier.new(c)
+          end
+
+          if a
+            arg = SQL::AliasedExpression.new(arg, a)
+          end
+
+          arg
         when SQL::Expression, LiteralString, SQL::Blob
           arg
         when Hash
@@ -573,8 +587,8 @@ module Sequel
       # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
       # and it is handled similarly to using a database independent type in the schema methods.
       #
-      #   :a.cast(:integer) # CAST(a AS integer)
-      #   :a.cast(String) # CAST(a AS varchar(255))
+      #   Sequel.function(:func).cast(:integer) # CAST(func() AS integer)
+      #   Sequel.function(:func).cast(String) # CAST(func() AS varchar(255))
       def cast(sql_type)
         Cast.new(self, sql_type)
       end
@@ -583,8 +597,8 @@ module Sequel
       # and return the result as a +NumericExpression+, so you can use the bitwise operators
       # on the result. 
       #
-      #   :a.cast_numeric # CAST(a AS integer)
-      #   :a.cast_numeric(Float) # CAST(a AS double precision)
+      #   Sequel.function(:func).cast_numeric # CAST(func() AS integer)
+      #   Sequel.function(:func).cast_numeric(Float) # CAST(func() AS double precision)
       def cast_numeric(sql_type = nil)
         cast(sql_type || Integer).sql_number
       end
@@ -593,13 +607,13 @@ module Sequel
       # and return the result as a +StringExpression+, so you can use +
       # directly on the result for SQL string concatenation.
       #
-      #   :a.cast_string # CAST(a AS varchar(255))
-      #   :a.cast_string(:text) # CAST(a AS text)
+      #   Sequel.function(:func).cast_string # CAST(func() AS varchar(255))
+      #   Sequel.function(:func).cast_string(:text) # CAST(func() AS text)
       def cast_string(sql_type = nil)
         cast(sql_type || String).sql_string
       end
     end
-    
+
     # Adds methods that allow you to treat an object as an instance of a specific
     # +ComplexExpression+ subclass.  This is useful if another library
     # overrides the methods defined by Sequel.
@@ -614,7 +628,7 @@ module Sequel
     #
     #   :price.sql_number/10 > 100
     module ComplexExpressionMethods
-      # Extract a datetime_part (e.g. year, month) from self:
+      # Extract a datetime part (e.g. year, month) from self:
       #
       #   :date.extract(:year) # extract(year FROM "date")
       #
@@ -646,25 +660,13 @@ module Sequel
       end
     end
 
-    # Includes an +identifier+ method that returns <tt>Identifier</tt>s.
-    module IdentifierMethods
-      # Return self wrapped as an <tt>SQL::Identifier</tt>.
-      #
-      #   :a__b # "a"."b"
-      #   :a__b.identifier # "a__b"
-      def identifier
-        Identifier.new(self)
-      end
-    end
-
     # This module includes the inequality methods (>, <, >=, <=) that are defined on objects that can be 
-    # used in a numeric or string context in SQL (+Symbol+ (except on ruby 1.9), +LiteralString+, 
-    # <tt>SQL::GenericExpression</tt>).
+    # used in a numeric or string context in SQL.
     #
-    #   'a'.lit > :b # a > "b"
-    #   'a'.lit < :b # a > "b"
-    #   'a'.lit >= :b # a >= "b"
-    #   'a'.lit <= :b # a <= "b"
+    #   Sequel.lit('a') > :b # a > "b"
+    #   Sequel.lit('a') < :b # a > "b"
+    #   Sequel.lit('a') >= :b # a >= "b"
+    #   Sequel.lit('a') <= :b # a <= "b"
     module InequalityMethods
       ComplexExpression::INEQUALITY_OPERATORS.each do |o|
         module_eval("def #{o}(o) BooleanExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
@@ -772,13 +774,25 @@ module Sequel
     end
 
     # Includes a +qualify+ method that created <tt>QualifiedIdentifier</tt>s, used for qualifying column
-    # names with a table or table names with a schema.
+    # names with a table or table names with a schema, and the * method for returning all columns in
+    # the identifier if no arguments are given.
     module QualifyingMethods
+      # If no arguments are given, return an SQL::ColumnAll:
+      #
+      #   Sequel.expr(:a__b).*  # a.b.*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new(self)
+        else
+          super(ce)
+        end
+      end
+
       # Qualify the receiver with the given +qualifier+ (table for column/schema for table).
       #
-      #   :column.qualify(:table) # "table"."column"
-      #   :table.qualify(:schema) # "schema"."table"
-      #   :column.qualify(:table).qualify(:schema) # "schema"."table"."column"
+      #   Sequel.expr(:column).qualify(:table) # "table"."column"
+      #   Sequel.expr(:table).qualify(:schema) # "schema"."table"
+      #   Sequel.qualify(:table, :column).qualify(:schema) # "schema"."table"."column"
       def qualify(qualifier)
         QualifiedIdentifier.new(qualifier, self)
       end
@@ -852,8 +866,16 @@ module Sequel
     # stored as a blob type in the database. Sequel represents binary data as a Blob object because 
     # most database engines require binary data to be escaped differently than regular strings.
     class Blob < ::String
-      # Returns +self+, used so that Blobs don't get wrapped in multiple
-      # levels.
+      include SQL::AliasMethods
+      include SQL::CastMethods
+
+      # Return a LiteralString with the same content if no args are given, otherwise
+      # return a SQL::PlaceholderLiteralString with the current string and the given args.
+      def lit(*args)
+        args.empty? ? LiteralString.new(self) : SQL::PlaceholderLiteralString.new(self, args)
+      end
+      
+      # Returns +self+, since it is already a blob.
       def to_sequel_blob
         self
       end
@@ -1570,20 +1592,18 @@ module Sequel
     include SQL::NumericMethods
     include SQL::StringMethods
     include SQL::InequalityMethods
-
-    # If the core extensions are enabled, these will already be included
-    # in String, so we don't need to include/define them here.
-    unless Sequel.core_extensions?
-      include Sequel::SQL::AliasMethods
-      include Sequel::SQL::CastMethods
+    include SQL::AliasMethods
+    include SQL::CastMethods
       
-      def lit(*args)
-        args.empty? ? self : SQL::PlaceholderLiteralString.new(self, args)
-      end
+    # Return self if no args are given, otherwise return a SQL::PlaceholderLiteralString
+    # with the current string and the given args.
+    def lit(*args)
+      args.empty? ? self : SQL::PlaceholderLiteralString.new(self, args)
+    end
       
-      def to_sequel_blob
-        SQL::Blob.new(self)
-      end
+    # Convert a literal string to a SQL::Blob.
+    def to_sequel_blob
+      SQL::Blob.new(self)
     end
   end
   

data/lib/sequel/version.rb

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

data/spec/adapters/mssql_spec.rb

@@ -19,20 +19,20 @@ end
 MSSQL_DB.loggers = [logger]
 
 MSSQL_DB.create_table! :test do
-  text :name
-  integer :value, :index => true
+  String :name, :type=>:text
+  Integer :value, :index => true
 end
 MSSQL_DB.create_table! :test2 do
-  text :name
-  integer :value
+  String :name, :type=>:text
+  Integer :value
 end
 MSSQL_DB.create_table! :test3 do
-  integer :value
-  timestamp :time
+  Integer :value
+  Time :time
 end
 MSSQL_DB.create_table! :test4 do
-  varchar :name, :size => 20
-  varbinary :value
+  String :name, :size => 20
+  column :value, 'varbinary(max)'
 end
 
 describe "A MSSQL database" do
@@ -115,7 +115,7 @@ describe "MSSQL Dataset#output" do
   specify "should format OUTPUT clauses without INTO for DELETE statements" do
     @ds.output(nil, [:deleted__name, :deleted__value]).delete_sql.should =~
       /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/
-    @ds.output(nil, [:deleted.*]).delete_sql.should =~
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:deleted)]).delete_sql.should =~
       /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].*/
   end
   
@@ -129,7 +129,7 @@ describe "MSSQL Dataset#output" do
   specify "should format OUTPUT clauses without INTO for INSERT statements" do
     @ds.output(nil, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
       /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/
-    @ds.output(nil, [:inserted.*]).insert_sql(:name => "name", :value => 1).should =~
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).insert_sql(:name => "name", :value => 1).should =~
       /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].* VALUES \((N'name'|1), (N'name'|1)\)/
   end
 
@@ -143,7 +143,7 @@ describe "MSSQL Dataset#output" do
   specify "should format OUTPUT clauses without INTO for UPDATE statements" do
     @ds.output(nil, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
       /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/
-    @ds.output(nil, [:inserted.*]).update_sql(:value => 2).should =~
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).update_sql(:value => 2).should =~
       /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[INSERTED\].*/
   end
 
@@ -329,7 +329,7 @@ describe "Common Table Expressions" do
 
   specify "using #with_recursive should be able to update" do
     ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1).or(:id => 1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
-    ds.filter(~{:id => @db[:t].select(:i)}).update(:parent_id => 1)
+    ds.exclude(:id => @db[:t].select(:i)).update(:parent_id => 1)
     @ds[:id => 1].should == {:id => 1, :parent_id => nil}
     @ds[:id => 2].should == {:id => 2, :parent_id => 1}
     @ds[:id => 5].should == {:id => 5, :parent_id => 3}
@@ -383,6 +383,7 @@ describe "MSSSQL::Dataset#insert" do
     @ds = @db[:test5]
   end
   after do
+    @db[:test4].delete
     @db.drop_table?(:test5)
   end
 
@@ -400,6 +401,14 @@ describe "MSSSQL::Dataset#insert" do
     h[:value].should == 10
     @ds.first(:xid=>h[:xid])[:value].should == 10
   end
+
+  cspecify "should allow large text and binary values", :odbc do
+    blob = Sequel::SQL::Blob.new("0" * (65*1024))
+    @db[:test4].insert(:name => 'max varbinary test', :value => blob)
+    b = @db[:test4].where(:name => 'max varbinary test').get(:value)
+    b.length.should == blob.length
+    b.should == blob
+  end
 end
 
 describe "MSSSQL::Dataset#disable_insert_output" do
@@ -542,3 +551,19 @@ describe "A MSSQL database adds index with include" do
     @db.indexes(@table_name).should have_key("#{@table_name}_col1_index".to_sym)
   end
 end
+
+describe "MSSQL::Database#drop_column with a schema" do
+  before do
+    MSSQL_DB.run "create schema test" rescue nil
+  end
+  after do
+    MSSQL_DB.drop_table(:test__items)
+    MSSQL_DB.run "drop schema test" rescue nil
+  end
+
+  specify "drops columns with a default value" do
+    MSSQL_DB.create_table!(:test__items){ Integer :id; String :name, :default => 'widget' }
+    MSSQL_DB.drop_column(:test__items, :name)
+    MSSQL_DB[:test__items].columns.should == [:id]
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -81,7 +81,7 @@ describe "MySQL", '#create_table' do
     @db.schema(:dolls).map{|k, v| v[:auto_increment]}.should == [nil, nil, true]
   end
 
-  cspecify "should support collate with various other column options", :swift do
+  specify "should support collate with various other column options" do
     @db.create_table!(:dolls){ String :name, :size=>128, :collate=>:utf8_bin, :default=>'foo', :null=>false, :unique=>true}
     @db[:dolls].insert
     @db[:dolls].select_map(:name).should == ["foo"]
@@ -164,72 +164,36 @@ describe "A MySQL dataset" do
 
   specify "should quote columns and tables using back-ticks if quoting identifiers" do
     @d.quote_identifiers = true
-    @d.select(:name).sql.should == \
-      'SELECT `name` FROM `items`'
-
-    @d.select('COUNT(*)'.lit).sql.should == \
-      'SELECT COUNT(*) FROM `items`'
-
-    @d.select(:max.sql_function(:value)).sql.should == \
-      'SELECT max(`value`) FROM `items`'
-
-    @d.select(:NOW.sql_function).sql.should == \
-    'SELECT NOW() FROM `items`'
-
-    @d.select(:max.sql_function(:items__value)).sql.should == \
-      'SELECT max(`items`.`value`) FROM `items`'
-
-    @d.order(:name.desc).sql.should == \
-      'SELECT * FROM `items` ORDER BY `name` DESC'
-
-    @d.select('items.name AS item_name'.lit).sql.should == \
-      'SELECT items.name AS item_name FROM `items`'
-
-    @d.select('`name`'.lit).sql.should == \
-      'SELECT `name` FROM `items`'
-
-    @d.select('max(items.`name`) AS `max_name`'.lit).sql.should == \
-      'SELECT max(items.`name`) AS `max_name` FROM `items`'
-
-    @d.select(:test.sql_function(:abc, 'hello')).sql.should == \
-      "SELECT test(`abc`, 'hello') FROM `items`"
-
-    @d.select(:test.sql_function(:abc__def, 'hello')).sql.should == \
-      "SELECT test(`abc`.`def`, 'hello') FROM `items`"
-
-    @d.select(:test.sql_function(:abc__def, 'hello').as(:x2)).sql.should == \
-      "SELECT test(`abc`.`def`, 'hello') AS `x2` FROM `items`"
-
-    @d.insert_sql(:value => 333).should == \
-      'INSERT INTO `items` (`value`) VALUES (333)'
-
-    @d.insert_sql(:x => :y).should == \
-      'INSERT INTO `items` (`x`) VALUES (`y`)'
+    @d.select(:name).sql.should == 'SELECT `name` FROM `items`'
+    @d.select(Sequel.lit('COUNT(*)')).sql.should == 'SELECT COUNT(*) FROM `items`'
+    @d.select(Sequel.function(:max, :value)).sql.should == 'SELECT max(`value`) FROM `items`'
+    @d.select(Sequel.function(:NOW)).sql.should == 'SELECT NOW() FROM `items`'
+    @d.select(Sequel.function(:max, :items__value)).sql.should == 'SELECT max(`items`.`value`) FROM `items`'
+    @d.order(Sequel.expr(:name).desc).sql.should == 'SELECT * FROM `items` ORDER BY `name` DESC'
+    @d.select(Sequel.lit('items.name AS item_name')).sql.should == 'SELECT items.name AS item_name FROM `items`'
+    @d.select(Sequel.lit('`name`')).sql.should == 'SELECT `name` FROM `items`'
+    @d.select(Sequel.lit('max(items.`name`) AS `max_name`')).sql.should == 'SELECT max(items.`name`) AS `max_name` FROM `items`'
+    @d.select(Sequel.function(:test, :abc, 'hello')).sql.should == "SELECT test(`abc`, 'hello') FROM `items`"
+    @d.select(Sequel.function(:test, :abc__def, 'hello')).sql.should == "SELECT test(`abc`.`def`, 'hello') FROM `items`"
+    @d.select(Sequel.function(:test, :abc__def, 'hello').as(:x2)).sql.should == "SELECT test(`abc`.`def`, 'hello') AS `x2` FROM `items`"
+    @d.insert_sql(:value => 333).should == 'INSERT INTO `items` (`value`) VALUES (333)'
+    @d.insert_sql(:x => :y).should == 'INSERT INTO `items` (`x`) VALUES (`y`)'
   end
 
   specify "should quote fields correctly when reversing the order" do
     @d.quote_identifiers = true
-    @d.reverse_order(:name).sql.should == \
-      'SELECT * FROM `items` ORDER BY `name` DESC'
-
-    @d.reverse_order(:name.desc).sql.should == \
-      'SELECT * FROM `items` ORDER BY `name` ASC'
-
-    @d.reverse_order(:name, :test.desc).sql.should == \
-      'SELECT * FROM `items` ORDER BY `name` DESC, `test` ASC'
-
-    @d.reverse_order(:name.desc, :test).sql.should == \
-      'SELECT * FROM `items` ORDER BY `name` ASC, `test` DESC'
+    @d.reverse_order(:name).sql.should == 'SELECT * FROM `items` ORDER BY `name` DESC'
+    @d.reverse_order(Sequel.desc(:name)).sql.should == 'SELECT * FROM `items` ORDER BY `name` ASC'
+    @d.reverse_order(:name, Sequel.desc(:test)).sql.should == 'SELECT * FROM `items` ORDER BY `name` DESC, `test` ASC'
+    @d.reverse_order(Sequel.desc(:name), :test).sql.should == 'SELECT * FROM `items` ORDER BY `name` ASC, `test` DESC'
   end
 
   specify "should support ORDER clause in UPDATE statements" do
-    @d.order(:name).update_sql(:value => 1).should == \
-      'UPDATE `items` SET `value` = 1 ORDER BY `name`'
+    @d.order(:name).update_sql(:value => 1).should == 'UPDATE `items` SET `value` = 1 ORDER BY `name`'
   end
 
   specify "should support LIMIT clause in UPDATE statements" do
-    @d.limit(10).update_sql(:value => 1).should == \
-      'UPDATE `items` SET `value` = 1 LIMIT 10'
+    @d.limit(10).update_sql(:value => 1).should == 'UPDATE `items` SET `value` = 1 LIMIT 10'
   end
 
   specify "should support regexps" do
@@ -272,9 +236,9 @@ describe "MySQL datasets" do
     @d.quote_identifiers = true
     market = 'ICE'
     ack_stamp = Time.now - 15 * 60 # 15 minutes ago
-    @d.select(:market, :minute.sql_function(:from_unixtime.sql_function(:ack)).as(:minute)).
-      where{|o|(:ack.sql_number > ack_stamp) & {:market => market}}.
-      group_by(:minute.sql_function(:from_unixtime.sql_function(:ack))).sql.should == \
+    @d.select(:market, Sequel.function(:minute, Sequel.function(:from_unixtime, :ack)).as(:minute)).
+      where{(ack > ack_stamp) & {:market => market}}.
+      group_by(Sequel.function(:minute, Sequel.function(:from_unixtime, :ack))).sql.should == \
       "SELECT `market`, minute(from_unixtime(`ack`)) AS `minute` FROM `orders` WHERE ((`ack` > #{@d.literal(ack_stamp)}) AND (`market` = 'ICE')) GROUP BY minute(from_unixtime(`ack`))"
   end
 end
@@ -296,7 +260,7 @@ describe "Dataset#distinct" do
     @ds.insert(20, 10)
     @ds.insert(30, 10)
     @ds.order(:b, :a).distinct.map(:a).should == [20, 30]
-    @ds.order(:b, :a.desc).distinct.map(:a).should == [30, 20]
+    @ds.order(:b, Sequel.desc(:a)).distinct.map(:a).should == [30, 20]
     # MySQL doesn't respect orders when using the nonstandard GROUP BY
     [[20], [30]].should include(@ds.order(:b, :a).distinct(:b).map(:a))
   end
@@ -1036,25 +1000,25 @@ describe "MySQL::Dataset#complex_expression_sql" do
   end
 
   specify "should handle pattern matches correctly" do
-    @d.literal(:x.like('a')).should == "(`x` LIKE BINARY 'a')"
-    @d.literal(~:x.like('a')).should == "(`x` NOT LIKE BINARY 'a')"
-    @d.literal(:x.ilike('a')).should == "(`x` LIKE 'a')"
-    @d.literal(~:x.ilike('a')).should == "(`x` NOT LIKE 'a')"
-    @d.literal(:x.like(/a/)).should == "(`x` REGEXP BINARY 'a')"
-    @d.literal(~:x.like(/a/)).should == "(`x` NOT REGEXP BINARY 'a')"
-    @d.literal(:x.like(/a/i)).should == "(`x` REGEXP 'a')"
-    @d.literal(~:x.like(/a/i)).should == "(`x` NOT REGEXP 'a')"
+    @d.literal(Sequel.expr(:x).like('a')).should == "(`x` LIKE BINARY 'a')"
+    @d.literal(~Sequel.expr(:x).like('a')).should == "(`x` NOT LIKE BINARY 'a')"
+    @d.literal(Sequel.expr(:x).ilike('a')).should == "(`x` LIKE 'a')"
+    @d.literal(~Sequel.expr(:x).ilike('a')).should == "(`x` NOT LIKE 'a')"
+    @d.literal(Sequel.expr(:x).like(/a/)).should == "(`x` REGEXP BINARY 'a')"
+    @d.literal(~Sequel.expr(:x).like(/a/)).should == "(`x` NOT REGEXP BINARY 'a')"
+    @d.literal(Sequel.expr(:x).like(/a/i)).should == "(`x` REGEXP 'a')"
+    @d.literal(~Sequel.expr(:x).like(/a/i)).should == "(`x` NOT REGEXP 'a')"
   end
 
   specify "should handle string concatenation with CONCAT if more than one record" do
-    @d.literal([:x, :y].sql_string_join).should == "CONCAT(`x`, `y`)"
-    @d.literal([:x, :y].sql_string_join(' ')).should == "CONCAT(`x`, ' ', `y`)"
-    @d.literal([:x.sql_function(:y), 1, 'z'.lit].sql_string_join(:y.sql_subscript(1))).should == "CONCAT(x(`y`), `y`[1], '1', `y`[1], z)"
+    @d.literal(Sequel.join([:x, :y])).should == "CONCAT(`x`, `y`)"
+    @d.literal(Sequel.join([:x, :y], ' ')).should == "CONCAT(`x`, ' ', `y`)"
+    @d.literal(Sequel.join([Sequel.function(:x, :y), 1, Sequel.lit('z')], Sequel.subscript(:y, 1))).should == "CONCAT(x(`y`), `y`[1], '1', `y`[1], z)"
   end
 
   specify "should handle string concatenation as simple string if just one record" do
-    @d.literal([:x].sql_string_join).should == "`x`"
-    @d.literal([:x].sql_string_join(' ')).should == "`x`"
+    @d.literal(Sequel.join([:x])).should == "`x`"
+    @d.literal(Sequel.join([:x], ' ')).should == "`x`"
   end
 end
 
@@ -1076,7 +1040,7 @@ describe "MySQL::Dataset#calc_found_rows" do
     MYSQL_DB.sqls.clear
 
     MYSQL_DB[:items].calc_found_rows.filter(:a => 1).limit(1).all.should == [{:a => 1}]
-    MYSQL_DB.dataset.select(:FOUND_ROWS.sql_function.as(:rows)).all.should == [{:rows => 2 }]
+    MYSQL_DB.dataset.select(Sequel.function(:FOUND_ROWS).as(:rows)).all.should == [{:rows => 2 }]
 
     MYSQL_DB.sqls.should == [
       'SELECT SQL_CALC_FOUND_ROWS * FROM `items` WHERE (`a` = 1) LIMIT 1',