Module: ROM::Solr::Query

Extended by:
Query
Includes:
Utils
Included in:
Query
Defined in:
lib/rom/solr/query.rb

Constant Summary collapse

ANY_VALUE = 
'[* TO *]'
OR = 
' OR '
AND = 
' AND '
DISJUNCTION =

Templates

'{!lucene q.op=OR df=%{field}}%{value}'
JOIN = 
'{!join from=%{from} to=%{to}}%{field}:%{value}'
NEGATION = 
'-%{field}:%{value}'
REGEXP = 
'%{field}:/%{value}/'
STANDARD = 
'%{field}:%{value}'
TERM = 
'{!term f=%{field}}%{value}'
NOOP =

Value transformers

->(v) { v }
ESCAPE = 
->(v) { escape(v) }
INTEGER = 
->(v) { v.to_i }
BEFORE_DATE = 
->(v) { '[* TO %s]' % solr_date(v) }
AFTER_DATE = 
->(v) { '[%s TO NOW]' % solr_date(v) }
BETWEEN_DATES = 
->(a, b) { '[%s TO %s]' % [solr_date(a), solr_date(b)] }
EXACT_DATE = 
->(v) { escape(solr_date(v)) }

Instance Method Summary collapse

Methods included from Utils

#escape, #phrase, #solr_date

Instance Method Details

#after(mapping) ⇒ Array<String>

Builds query clause(s) to filter where date field value is later than a date/time value.

Parameters:

  • mapping (Hash) —

    field=>value mapping Values (coerced to strings) must be parseable by DateTime.parse.

Returns:

  • (Array<String>) —

    queries



96
97
98
 
# File 'lib/rom/solr/query.rb', line 96

def after(mapping)
  render(STANDARD, mapping, AFTER_DATE)
end

#before(mapping) ⇒ Array<String>

Builds query clause(s) to filter where date field value is earlier than a date/time value.

Parameters:

  • mapping (Hash) —

    field=>value mapping Values (coerced to strings) must be parseable by DateTime.parse.

Returns:

  • (Array<String>) —

    queries



86
87
88
 
# File 'lib/rom/solr/query.rb', line 86

def before(mapping)
  render(STANDARD, mapping, BEFORE_DATE)
end

#between_dates(mapping) ⇒ Object 



100
101
102
 
# File 'lib/rom/solr/query.rb', line 100

def between_dates(mapping)
  render(STANDARD, mapping, BETWEEN_DATES)
end

#exact_date(mapping) ⇒ Object 



104
105
106
 
# File 'lib/rom/solr/query.rb', line 104

def exact_date(mapping)
  render(STANDARD, mapping, EXACT_DATE)
end

#exist(*fields) ⇒ Array<String>

Builds query clause(s) to filter where field is present (i.e., has one or more values)

Parameters:

  • fields (Array<String>) —

    on or more fields

Returns:

  • (Array<String>) —

    queries



51
52
53
54
55
 
# File 'lib/rom/solr/query.rb', line 51

def exist(*fields)
  mapping = fields.map { |field| {field: field, value: ANY_VALUE} }

  render(STANDARD, mapping)
end

#join(from:, to:, field:, value:) ⇒ Array<String>

Builds a Solr join clause

Parameters:

  • from (String)
  • to (String)
  • field (String)
  • value (String)

Returns:

  • (Array<String>) —

    queries

See Also:



76
77
78
 
# File 'lib/rom/solr/query.rb', line 76

def join(from:, to:, field:, value:)
  [ JOIN % { from: from, to: to, field: field, value: value } ]
end

#not_exist(*fields) ⇒ Array<String>

Builds query clause(s) to filter where field is NOT present (i.e., no values)

Parameters:

  • fields (Array<Symbol, String>) —

    one or more fields

Returns:

  • (Array<String>) —

    queries



62
63
64
65
66
 
# File 'lib/rom/solr/query.rb', line 62

def not_exist(*fields)
  mapping = fields.map { |field| {field: "-#{field}", value: ANY_VALUE} }

  render(STANDARD, mapping)
end

#regexp(mapping) ⇒ Array<String>

Builds regular expression query clause(s).

Parameters:

  • mapping (Hash) —

    field=>value mapping

Returns:

  • (Array<String>) —

    queries



120
121
122
 
# File 'lib/rom/solr/query.rb', line 120

def regexp(mapping)
  render(REGEXP, mapping, ESCAPE_SLASHE)
end

#term(mapping) ⇒ Array<String>

Builds term query clause(s) to filter where field contains value.

Parameters:

  • mapping (Hash) —

    field=>value mapping

Returns:

  • (Array<String>) —

    queries



112
113
114
 
# File 'lib/rom/solr/query.rb', line 112

def term(mapping)
  render(TERM, mapping)
end

#where(mapping) ⇒ Array<String>

Build standard query clause(s) – i.e., field:value – and disjunction clauses (i.e., when value is an array).

Parameters:

  • mapping (Hash) —

    field=>value mapping

Returns:

  • (Array<String>) —

    queries



34
35
36
 
# File 'lib/rom/solr/query.rb', line 34

def where(mapping)
  render(STANDARD, mapping, ->(v) { Array.wrap(v).join(OR) })
end

#where_not(mapping) ⇒ Array<String>

Builds negation clause(s) – i.e., -field:value

Parameters:

  • mapping (Hash) —

    field=>value mapping

Returns:

  • (Array<String>) —

    queries



42
43
44
 
# File 'lib/rom/solr/query.rb', line 42

def where_not(mapping)
  render(NEGATION, mapping)
end