Class: Sequel::SQL::VirtualRow
- Inherits:
- BasicObject
- Defined in:
- lib/sequel/sql.rb
Overview
The purpose of the VirtualRow
class is to allow the easy creation of SQL identifiers and functions without relying on methods defined on Symbol
. This is useful if another library defines the methods defined by Sequel, if you are running on ruby 1.9, or if you are not using the core extensions.
An instance of this class is yielded to the block supplied to Dataset#filter
, Dataset#order
, and Dataset#select
(and the other methods that accept a block and pass it to one of those methods). If the block doesn’t take an argument, the block is instance_evaled in the context of a new instance of this class.
VirtualRow
uses method_missing
to return either an Identifier
, QualifiedIdentifier
, Function
, or WindowFunction
, depending on how it is called.
If a block is not given, creates one of the following objects:
Function
-
Returned if any arguments are supplied, using the method name as the function name, and the arguments as the function arguments.
QualifiedIdentifier
-
Returned if the method name contains __, with the table being the part before __, and the column being the part after.
Identifier
-
Returned otherwise, using the method name.
If a block is given, it returns either a Function
or WindowFunction
, depending on the first argument to the method. Note that the block is currently not called by the code, though this may change in a future version. If the first argument is:
- no arguments given
-
creates a
Function
with no arguments. - :*
-
creates a
Function
with a literal wildcard argument (*), mostly useful for COUNT. - :distinct
-
creates a
Function
that prepends DISTINCT to the rest of the arguments, mostly useful for aggregate functions. - :over
-
creates a
WindowFunction
. If a second argument is provided, it should be a hash of options which are passed to Window (with possible keys :window, :partition, :order, and :frame). The arguments to the function itself should be specified as:*=>true
for a wildcard, or via the:args
option.
Examples:
ds = DB[:t]
# Argument yielded to block
ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
# Block without argument (instance_eval)
ds.filter{name < 2} # SELECT * FROM t WHERE (name < 2)
# Qualified identifiers
ds.filter{table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
# Functions
ds.filter{is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
ds.select{version{}} # SELECT version() FROM t
ds.select{count(:*){}} # SELECT count(*) FROM t
ds.select{count(:distinct, col1){}} # SELECT count(DISTINCT col1) FROM t
# Window Functions
ds.select{rank(:over){}} # SELECT rank() OVER () FROM t
ds.select{count(:over, :*=>true){}} # SELECT count(*) OVER () FROM t
ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}} # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM t
For a more detailed explanation, see the Virtual Rows guide.
Constant Summary collapse
- WILDCARD =
LiteralString.new('*').freeze
- QUESTION_MARK =
LiteralString.new('?').freeze
- COMMA_SEPARATOR =
LiteralString.new(', ').freeze
- DOUBLE_UNDERSCORE =
'__'.freeze
Constants inherited from BasicObject
Instance Method Summary collapse
-
#method_missing(m, *args, &block) ⇒ Object
Return an
Identifier
,QualifiedIdentifier
,Function
, orWindowFunction
, depending on arguments and whether a block is provided.
Methods inherited from BasicObject
const_missing, remove_methods!
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(m, *args, &block) ⇒ Object
Return an Identifier
, QualifiedIdentifier
, Function
, or WindowFunction
, depending on arguments and whether a block is provided. Does not currently call the block. See the class level documentation.
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 |
# File 'lib/sequel/sql.rb', line 1105 def method_missing(m, *args, &block) if block if args.empty? Function.new(m) else case arg = args.shift when :* Function.new(m, WILDCARD) when :distinct Function.new(m, PlaceholderLiteralString.new("DISTINCT #{args.map{QUESTION_MARK}.join(COMMA_SEPARATOR)}", args)) when :over opts = args.shift || {} fun_args = ::Kernel.Array(opts[:*] ? WILDCARD : opts[:args]) WindowFunction.new(Function.new(m, *fun_args), Window.new(opts)) else raise Error, 'unsupported VirtualRow method argument used with block' end end elsif args.empty? table, column = m.to_s.split(DOUBLE_UNDERSCORE, 2) column ? QualifiedIdentifier.new(table, column) : Identifier.new(m) else Function.new(m, *args) end end |