class Sequel::SQL::Function

Represents an SQL function call.

Constants

COMMA_ARRAY
DISTINCT
WILDCARD

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) click to toggle source

Set the name and args for the function

     # File lib/sequel/sql.rb
1311 def initialize(name, *args)
1312   _initialize(name, args, OPTS)
1313 end

Public Instance Methods

*(ce=(arg=false;nil)) click to toggle source

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

Sequel.function(:count).*  # count(*)
Calls superclass method
     # File lib/sequel/sql.rb
1323 def *(ce=(arg=false;nil))
1324   if arg == false
1325     raise Error, "Cannot apply * to functions with arguments" unless args.empty?
1326     with_opts(:"*"=>true)
1327   else
1328     super(ce)
1329   end
1330 end
distinct() click to toggle source

Return a new function with DISTINCT before the method arguments.

Sequel.function(:count, :col).distinct # count(DISTINCT col)
     # File lib/sequel/sql.rb
1335 def distinct
1336   with_opts(:distinct=>true)
1337 end
filter(*args, &block) click to toggle source

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))
     # File lib/sequel/sql.rb
1343 def filter(*args, &block)
1344   if args.length == 1
1345     args = args.first
1346   else
1347     args.freeze
1348   end
1349 
1350   with_opts(:filter=>args, :filter_block=>block)
1351 end
lateral() click to toggle source

Return a function which will use LATERAL when literalized:

Sequel.function(:foo, :col).lateral # LATERAL foo(col)
     # File lib/sequel/sql.rb
1356 def lateral
1357   with_opts(:lateral=>true)
1358 end
order(*args) click to toggle source

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)
     # File lib/sequel/sql.rb
1364 def order(*args)
1365   with_opts(:order=>args.freeze)
1366 end
over(window=OPTS) click to toggle source

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)
     # File lib/sequel/sql.rb
1372 def over(window=OPTS)
1373   raise Error, "function already has a window applied to it" if opts[:over]
1374   window = Window.new(window) unless window.is_a?(Window)
1375   with_opts(:over=>window)
1376 end
quoted() click to toggle source

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

Sequel.function(:foo).quoted # "foo"()
     # File lib/sequel/sql.rb
1382 def quoted
1383   with_opts(:quoted=>true)
1384 end
unquoted() click to toggle source

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()
     # File lib/sequel/sql.rb
1390 def unquoted
1391   with_opts(:quoted=>false)
1392 end
with_ordinality() click to toggle source

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
     # File lib/sequel/sql.rb
1398 def with_ordinality
1399   with_opts(:with_ordinality=>true)
1400 end
within_group(*expressions) click to toggle source

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)
     # File lib/sequel/sql.rb
1407 def within_group(*expressions)
1408   with_opts(:within_group=>expressions.freeze)
1409 end

Private Instance Methods

_initialize(name, args, opts) click to toggle source

Set name, args, and opts

     # File lib/sequel/sql.rb
1416 def _initialize(name, args, opts)
1417   @name = name
1418   @args = args.freeze
1419   @opts = opts.freeze
1420   freeze
1421 end
inspect_new_method() click to toggle source

Function uses a new! method for creating functions with options, since Function.new does not allow for an options hash.

    # File lib/sequel/extensions/eval_inspect.rb
137 def inspect_new_method
138   :new!
139 end
with_opts(opts) click to toggle source

Return a new function call with the given opts merged into the current opts.

     # File lib/sequel/sql.rb
1424 def with_opts(opts)
1425   self.class.new!(name, args, Hash[@opts].merge!(opts))
1426 end