Class: Sequel::SQL::StringExpression

Inherits:
ComplexExpression show all
Includes:
InequalityMethods, StringConcatenationMethods, StringMethods
Defined in:
lib/sequel/sql.rb

Overview

Subclass of ComplexExpression where the expression results in a text/string/varchar value in SQL.

Constant Summary collapse

LIKE_MAP =

Map of [regexp, case_insenstive] to ComplexExpression operator symbol

{[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE}.freeze

Constants inherited from ComplexExpression

ComplexExpression::ASSOCIATIVE_OPERATORS, ComplexExpression::BITWISE_OPERATORS, ComplexExpression::BOOLEAN_OPERATOR_METHODS, ComplexExpression::CONSTANT_INVERSIONS, ComplexExpression::CUSTOM_EXPRESSIONS, ComplexExpression::EQUALITY_OPERATORS, ComplexExpression::INEQUALITY_OPERATORS, ComplexExpression::IN_OPERATORS, ComplexExpression::IS_OPERATORS, ComplexExpression::LIKE_OPERATORS, ComplexExpression::MATHEMATICAL_OPERATORS, ComplexExpression::N_ARITY_OPERATORS, ComplexExpression::ONE_ARITY_OPERATORS, ComplexExpression::OPERATOR_INVERSIONS, ComplexExpression::OPERTATOR_INVERSIONS, ComplexExpression::REGEXP_OPERATORS, ComplexExpression::TWO_ARITY_OPERATORS

Instance Attribute Summary

Attributes inherited from ComplexExpression

#args, #op

Class Method Summary collapse

Instance Method Summary collapse

Methods included from StringConcatenationMethods

#+

Methods included from StringMethods

#escaped_ilike, #escaped_like, #ilike, #like

Methods inherited from ComplexExpression

#initialize, #sql_boolean, #sql_number

Methods included from SubscriptMethods

#sql_subscript

Methods included from PatternMatchMethods

#!~, #=~

Methods included from OrderMethods

#asc, #desc

Methods included from CastMethods

#cast, #cast_numeric, #cast_string

Methods included from AliasMethods

#as

Methods inherited from Expression

#==, attr_reader, #clone, #eql?, #hash, inherited, #inspect

Constructor Details

This class inherits a constructor from Sequel::SQL::ComplexExpression

Class Method Details

.like(l, *ces) ⇒ Object

Creates a SQL pattern match exprssion. left (l) is the SQL string we are matching against, and ces are the patterns we are matching. The match succeeds if any of the patterns match (SQL OR).

If a regular expression is used as a pattern, an SQL regular expression will be used, which is currently only supported on some databases. Be aware that SQL regular expression syntax is similar to ruby regular expression syntax, but it not exactly the same, especially for advanced regular expression features. Sequel just uses the source of the ruby regular expression verbatim as the SQL regular expression string.

If any other object is used as a regular expression, the SQL LIKE operator will be used, and should be supported by most databases.

The pattern match will be case insensitive if the last argument is a hash with a key of :case_insensitive that is not false or nil. Also, if a case insensitive regular expression is used (//i), that particular pattern which will always be case insensitive.

StringExpression.like(:a, 'a%') # ("a" LIKE 'a%' ESCAPE '\')
StringExpression.like(:a, 'a%', case_insensitive: true) # ("a" ILIKE 'a%' ESCAPE '\')
StringExpression.like(:a, 'a%', /^a/i) # (("a" LIKE 'a%' ESCAPE '\') OR ("a" ~* '^a'))



1772
1773
1774
1775
1776
1777
1778
1779
1780
 
# File 'lib/sequel/sql.rb', line 1772

def self.like(l, *ces)
  l, lre, lci = like_element(l)
  lci = (ces.last.is_a?(Hash) ? ces.pop : OPTS)[:case_insensitive] ? true : lci
  ces.map! do |ce|
    r, rre, rci = like_element(ce)
    BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)
  end
  ces.length == 1 ? ces[0] : BooleanExpression.new(:OR, *ces)
end

Instance Method Details

#sql_string ⇒ Object

Return self instead of creating a new object to save on memory.



1796
1797
1798
 
# File 'lib/sequel/sql.rb', line 1796

def sql_string
  self
end