class Sequel::SQL::Function

  1. lib/sequel/sql.rb
Superclass: GenericExpression

Represents an SQL function call.

Constants

COMMA_ARRAY = [LiteralString.new(', ').freeze].freeze  
DISTINCT = ["DISTINCT ".freeze].freeze  
WILDCARD = LiteralString.new('*').freeze  

Attributes

args [R]

The array of arguments to pass to the function (may be blank)
name [R]

The SQL function to call
opts [R]

Options for this function

Public Class methods

new(name, *args)

Set the name and args for the function

[show source] 
     # File lib/sequel/sql.rb
1386 def initialize(name, *args)
1387   _initialize(name, args, OPTS)
1388 end

Public Instance methods

*(ce=(arg=false;nil))

If no arguments are given, return a new function with the wildcard prepended to the arguments.

Sequel.function(:count).*  # count(*)
[show source] 
     # File lib/sequel/sql.rb
1398 def *(ce=(arg=false;nil))
1399   if arg == false
1400     raise Error, "Cannot apply * to functions with arguments" unless args.empty?
1401     with_opts(:"*"=>true)
1402   else
1403     super(ce)
1404   end
1405 end
distinct()

Return a new function with DISTINCT before the method arguments.

Sequel.function(:count, :col).distinct # count(DISTINCT col)
[show source] 
     # File lib/sequel/sql.rb
1410 def distinct
1411   with_opts(:distinct=>true)
1412 end
filter(*args, &block)

Return a new function with FILTER added to it, for filtered aggregate functions:

Sequel.function(:foo, :col).filter(a: 1) # foo(col) FILTER (WHERE (a = 1))
[show source] 
     # File lib/sequel/sql.rb
1418 def filter(*args, &block)
1419   if args.length == 1
1420     args = args.first
1421   else
1422     args.freeze
1423   end
1424 
1425   with_opts(:filter=>args, :filter_block=>block)
1426 end
lateral()

Return a function which will use LATERAL when literalized:

Sequel.function(:foo, :col).lateral # LATERAL foo(col)
[show source] 
     # File lib/sequel/sql.rb
1431 def lateral
1432   with_opts(:lateral=>true)
1433 end
order(*args)

Return a new function where the function will be ordered. Only useful for aggregate functions that are order dependent.

Sequel.function(:foo, :a).order(:a, Sequel.desc(:b)) # foo(a ORDER BY a, b DESC)
[show source] 
     # File lib/sequel/sql.rb
1439 def order(*args)
1440   with_opts(:order=>args.freeze)
1441 end
over(window=OPTS)

Return a new function with an OVER clause (making it a window function). See Sequel::SQL::Window for the list of options over can receive.

Sequel.function(:row_number).over(partition: :col) # row_number() OVER (PARTITION BY col)
[show source] 
     # File lib/sequel/sql.rb
1447 def over(window=OPTS)
1448   raise Error, "function already has a window applied to it" if opts[:over]
1449   window = Window.new(window) unless window.is_a?(Window)
1450   with_opts(:over=>window)
1451 end
quoted()

Return a new function where the function name will be quoted if the database supports quoted functions:

Sequel.function(:foo).quoted # "foo"()
[show source] 
     # File lib/sequel/sql.rb
1457 def quoted
1458   with_opts(:quoted=>true)
1459 end
unquoted()

Return a new function where the function name will not be quoted even if the database supports quoted functions:

Sequel[:foo][:bar].function.unquoted # foo.bar()
[show source] 
     # File lib/sequel/sql.rb
1465 def unquoted
1466   with_opts(:quoted=>false)
1467 end
with_ordinality()

Return a new function that will use WITH ORDINALITY to also return a row number for every row the function returns:

Sequel.function(:foo).with_ordinality # foo() WITH ORDINALITY
[show source] 
     # File lib/sequel/sql.rb
1473 def with_ordinality
1474   with_opts(:with_ordinality=>true)
1475 end
within_group(*expressions)

Return a new function that uses WITHIN GROUP ordered by the given expression, useful for ordered-set and hypothetical-set aggregate functions:

Sequel.function(:rank, :a).within_group(:b, :c)
# rank(a) WITHIN GROUP (ORDER BY b, c)
[show source] 
     # File lib/sequel/sql.rb
1482 def within_group(*expressions)
1483   with_opts(:within_group=>expressions.freeze)
1484 end