Class | Sequel::SQL::StringExpression
In: | lib/sequel/sql.rb
Parent: | ComplexExpression

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

### Methods

like sql_string

### Included Modules

StringMethods StringConcatenationMethods InequalityMethods

### Constants

LIKE_MAP | = | {[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE} |  | Map of [regexp, case_insenstive] to `ComplexExpression` operator symbol

### Public Class methods

like(l, *ces)

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 MySQL and PostgreSQL. Be aware that MySQL and PostgreSQL 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%'
      StringExpression.like(:a, 'a%', :case_insensitive=>true) # "a" ILIKE 'a%'
      StringExpression.like(:a, 'a%', /^a/i) # "a" LIKE 'a%' OR "a" ~* '^a'

[Source]

          # File lib/sequel/sql.rb, line 1331
    1331:       def self.like(l, *ces)
    1332:         l, lre, lci = like_element(l)
    1333:         lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
    1334:         ces.collect! do |ce|
    1335:           r, rre, rci = like_element(ce)
    1336:           BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)
    1337:         end
    1338:         ces.length == 1 ? ces.at(0) : BooleanExpression.new(:OR, *ces)
    1339:       end

### Public Instance methods

sql_string()

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

[Source]

          # File lib/sequel/sql.rb, line 1355
    1355:       def sql_string
    1356:         self
    1357:       end

[Validate]