/usr/lib/ruby/vendor_ruby/sequel/core_sql.rb is in ruby-sequel 3.33.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 | # Sequel extends +Array+ to add methods to implement the SQL DSL.
# Most of these methods require that the array not be empty and that it
# must consist solely of other arrays that have exactly two elements.
class Array
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
# conditions.
#
# ~[[:a, true]] # SQL: a IS NOT TRUE
# ~[[:a, 1], [:b, [2, 3]]] # SQL: a != 1 OR b NOT IN (2, 3)
def ~
sql_expr_if_all_two_pairs(:OR, true)
end
# +true+ if the array is not empty and all of its elements are
# arrays of size 2, +false+ otherwise. This is used to determine if the array
# could be a specifier of conditions, used similarly to a hash
# but allowing for duplicate keys and a specific order.
#
# [].to_a.all_two_pairs? # => false
# [:a].to_a.all_two_pairs? # => false
# [[:b]].to_a.all_two_pairs? # => false
# [[:a, 1]].to_a.all_two_pairs? # => true
def all_two_pairs?
!empty? && all?{|i| (Array === i) && (i.length == 2)}
end
# Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
# default value and expression.
#
# [[{:a=>[2,3]}, 1]].case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
# [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
def case(*args)
::Sequel::SQL::CaseExpression.new(self, *args)
end
# Return a <tt>Sequel::SQL::ValueList</tt> created from this array. Used if this array contains
# all two element arrays and you want it treated as an SQL value list (IN predicate)
# instead of as a conditions specifier (similar to a hash). This is not necessary if you are using
# this array as a value in a filter, but may be necessary if you are using it as a
# value with placeholder SQL:
#
# DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
# DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
# DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
def sql_value_list
::Sequel::SQL::ValueList.new(self)
end
# Deprecated alias for sql_value_list
alias sql_array sql_value_list
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
# conditions. Rarely do you need to call this explicitly, as Sequel generally
# assumes that arrays of two element arrays specify this type of condition. One case where
# it can be necessary to use this is if you are using the object as a value in a filter hash
# and want to use the = operator instead of the IN operator (which is used by default for
# arrays of two element arrays).
#
# [[:a, true]].sql_expr # SQL: a IS TRUE
# [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
def sql_expr
sql_expr_if_all_two_pairs
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none
# of the conditions.
#
# [[:a, true]].sql_negate # SQL: a IS NOT TRUE
# [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
def sql_negate
sql_expr_if_all_two_pairs(:AND, true)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching any of the
# conditions.
#
# [[:a, true]].sql_or # SQL: a IS TRUE
# [[:a, 1], [:b, [2, 3]]].sql_or # SQL: a = 1 OR b IN (2, 3)
def sql_or
sql_expr_if_all_two_pairs(:OR)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> representing an SQL string made up of the
# concatenation of this array's elements. If an argument is passed
# it is used in between each element of the array in the SQL
# concatenation.
#
# [:a].sql_string_join # SQL: a
# [:a, :b].sql_string_join # SQL: a || b
# [:a, 'b'].sql_string_join # SQL: a || 'b'
# ['a', :b].sql_string_join(' ') # SQL: 'a' || ' ' || b
def sql_string_join(joiner=nil)
if joiner
args = zip([joiner]*length).flatten
args.pop
else
args = self
end
args = args.collect{|a| [Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass].any?{|c| a.is_a?(c)} ? a : a.to_s}
::Sequel::SQL::StringExpression.new(:'||', *args)
end
private
# Raise an error if this array is not made up all two element arrays, otherwise create a <tt>Sequel::SQL::BooleanExpression</tt> from this array.
def sql_expr_if_all_two_pairs(*args)
raise(Sequel::Error, 'Not all elements of the array are arrays of size 2, so it cannot be converted to an SQL expression') unless all_two_pairs?
::Sequel::SQL::BooleanExpression.from_value_pairs(self, *args)
end
end
# Sequel extends +Hash+ to add methods to implement the SQL DSL.
class Hash
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
# all of the conditions in this hash and the condition specified by
# the given argument.
#
# {:a=>1} & :b # SQL: a = 1 AND b
# {:a=>true} & ~:b # SQL: a IS TRUE AND NOT b
def &(ce)
::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
# all of the conditions in this hash or the condition specified by
# the given argument.
#
# {:a=>1} | :b # SQL: a = 1 OR b
# {:a=>true} | ~:b # SQL: a IS TRUE OR NOT b
def |(ce)
::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, not matching all of the
# conditions.
#
# ~{:a=>true} # SQL: a IS NOT TRUE
# ~{:a=>1, :b=>[2, 3]} # SQL: a != 1 OR b NOT IN (2, 3)
def ~
::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
end
# Return a <tt>Sequel::SQL::CaseExpression</tt> with this hash as the conditions and the given
# default value. Note that the order of the conditions will be arbitrary on ruby 1.8, so all
# conditions should be orthogonal.
#
# {{:a=>[2,3]}=>1}.case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
# {:a=>1, :b=>2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
# # or: CASE c WHEN b THEN 2 WHEN a THEN 1 ELSE d END
def case(*args)
::Sequel::SQL::CaseExpression.new(to_a, *args)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching all of the
# conditions. Rarely do you need to call this explicitly, as Sequel generally
# assumes that hashes specify this type of condition.
#
# {:a=>true}.sql_expr # SQL: a IS TRUE
# {:a=>1, :b=>[2, 3]}.sql_expr # SQL: a = 1 AND b IN (2, 3)
def sql_expr
::Sequel::SQL::BooleanExpression.from_value_pairs(self)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching none
# of the conditions.
#
# {:a=>true}.sql_negate # SQL: a IS NOT TRUE
# {:a=>1, :b=>[2, 3]}.sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
def sql_negate
::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
end
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching any of the
# conditions.
#
# {:a=>true}.sql_or # SQL: a IS TRUE
# {:a=>1, :b=>[2, 3]}.sql_or # SQL: a = 1 OR b IN (2, 3)
def sql_or
::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
end
end
# Sequel extends +String+ to add methods to implement the SQL DSL.
class String
include Sequel::SQL::AliasMethods
include Sequel::SQL::CastMethods
# Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
# literalization, e.g.:
#
# DB[:items].filter(:abc => 'def').sql #=>
# "SELECT * FROM items WHERE (abc = 'def')"
#
# DB[:items].filter(:abc => 'def'.lit).sql #=>
# "SELECT * FROM items WHERE (abc = def)"
#
# You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
#
# DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
# "SELECT count(DISTINCT a) FROM items"
def lit(*args)
args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
end
# Returns a <tt>Sequel::SQL::Blob</tt> that holds the same data as this string. Blobs provide proper
# escaping of binary data.
def to_sequel_blob
::Sequel::SQL::Blob.new(self)
end
end
# Sequel extends +Symbol+ to add methods to implement the SQL DSL.
class Symbol
include Sequel::SQL::QualifyingMethods
include Sequel::SQL::IdentifierMethods
include Sequel::SQL::AliasMethods
include Sequel::SQL::CastMethods
include Sequel::SQL::OrderMethods
include Sequel::SQL::BooleanMethods
include Sequel::SQL::NumericMethods
include Sequel::SQL::StringMethods
include Sequel::SQL::SubscriptMethods
include Sequel::SQL::ComplexExpressionMethods
include Sequel::SQL::InequalityMethods if RUBY_VERSION < '1.9.0'
# If no argument is given, returns a <tt>Sequel::SQL::ColumnAll</tt> object specifying all
# columns for this table.
# If an argument is given, returns a <tt>Sequel::SQL::NumericExpression</tt> using the *
# (multiplication) operator with this and the given argument.
#
# :table.* # SQL: table.*
# :column * 2 # SQL: column * 2
def *(ce=(arg=false;nil))
return super(ce) unless arg == false
Sequel::SQL::ColumnAll.new(self);
end
# Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,
# and the given arguments. This is aliased as <tt>Symbol#[]</tt> if the RUBY_VERSION
# is less than 1.9.0. Ruby 1.9 defines <tt>Symbol#[]</tt>, and Sequel
# doesn't override methods defined by ruby itself.
#
# :now.sql_function # SQL: now()
# :sum.sql_function(:a) # SQL: sum(a)
# :concat.sql_function(:a, :b) # SQL: concat(a, b)
def sql_function(*args)
Sequel::SQL::Function.new(self, *args)
end
alias_method(:[], :sql_function) if RUBY_VERSION < '1.9.0'
end
|