Class: Groonga::Client::Request::Select

Inherits:
Generic
  • Object
show all
Includes:
Enumerable
Defined in:
lib/groonga/client/request/select.rb

Defined Under Namespace

Modules: ScriptSyntaxValueEscapable Classes: BackwardCompatibleSortKeysParameter, DynamicColumn, DynamicColumnWindow, Filter, FilterExpressionParameter, FilterMerger, LabeledDrilldown, OutputColumnsParameter, QueryMerger, ScorerExpressionParameter, ScriptSyntaxExpressionParameter, SortKeysParameter

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Generic

#command_name, #extensions, #flags_parameter, #parameter, #response, #to_parameters, #values_parameter

Constructor Details

#initialize(table_or_parameters, extensions = []) ⇒ Select

Returns a new instance of Select.



31
32
33
34
35
36
37
38
39
 
# File 'lib/groonga/client/request/select.rb', line 31

def initialize(table_or_parameters, extensions=[])
  if table_or_parameters.respond_to?(:to_parameters)
    parameters = table_or_parameters
  else
    table_name = table_or_parameters
    parameters = RequestParameter.new(:table, table_name)
  end
  super(parameters, extensions)
end

Class Method Details

.command_name ⇒ Object 



24
25
26
 
# File 'lib/groonga/client/request/select.rb', line 24

def command_name
  "select"
end

Instance Method Details

#columns(label) ⇒ Object 



296
297
298
 
# File 'lib/groonga/client/request/select.rb', line 296

def columns(label)
  DynamicColumn.new(self, label)
end

#drilldowns(label) ⇒ Object 



292
293
294
 
# File 'lib/groonga/client/request/select.rb', line 292

def drilldowns(label)
  LabeledDrilldown.new(self, label)
end

#each(&block) ⇒ Object 



300
301
302
 
# File 'lib/groonga/client/request/select.rb', line 300

def each(&block)
  response.records.each(&block)
end

#filter(column_name, value) ⇒ Groonga::Client::Request::Select #filter(expression, values = nil) ⇒ Groonga::Client::Request::Select #filter ⇒ Groonga::Client::Request::Select::Filter

Adds a script syntax condition. If the request already has any filter condition, they are combined by AND.

Examples:

Multiple filters

request.
  filter(:user, "alice").
    # -> --filter 'user == "alice"'
  filter("tags @ %{tag}", tag: "Ruby")
    # -> --filter '(user == "alice") && (tags @ "Ruby")'

Overloads:

  • #filter(column_name, value) ⇒ Groonga::Client::Request::Select

    Adds a #{column_name} == #{value} condition.

    Parameters:

    • column_name (Symbol) —

      The target column name.

    • value (Object) —

      The column value. It's escaped automatically.

  • #filter(expression, values = nil) ⇒ Groonga::Client::Request::Select

    Adds a #{expression % values} condition.

    Parameters:

    • expression (String) —

      The script syntax expression. It can includes %{name}s as placeholder. They are expanded by String#% with the given values argument.

    • values (nil, ::Hash) (defaults to: nil) —

      The values to be expanded. If the given expression doesn't have placeholder, you should specify nil.

      Values are escaped automatically. Values passed from external should be escaped.

  • #filter ⇒ Groonga::Client::Request::Select::Filter

    Returns a request object for filter condition. It provides convenient methods to add a popular filter condition.

    @example: Use geo_in_rectangle function request. filter.geo_in_rectangle(:location, "0x100", "100x0") # -> --filter 'geo_in_rectangle(location, "0x100", "100x0")'

    Examples:

    Use in_values function

    request.
  filter.in_values(:tags, "tag1", "tag2")
    # -> --filter 'in_values(tags, "tag1", "tag2")'

    Use geo_in_circle function

    request.
  filter.geo_in_circle(:location, "100x100", 300)
    # -> --filter 'geo_in_circle(location, "100x100", 300, "rectangle")'

    Use between function

    request.
  filter.between(:age, 19, "include", 32, "include")
    # -> --filter 'between(age, 19, "include", 32, "include")'

    Returns:

    Since:

    • 0.4.3

Returns:



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
 
# File 'lib/groonga/client/request/select.rb', line 163

def filter(*args)
  n_args = args.size
  case n_args
  when 0
    Filter.new(self)
  when 1, 2
    expression_or_column_name, values_or_value = *args

    if values_or_value.nil? or values_or_value.is_a?(::Hash)
      expression = expression_or_column_name
      values = values_or_value
    else
      expression = "%{column} == %{value}"
      column_name = expression_or_column_name
      column_name = Filter.column_namify(column_name,
                                         "first",
                                         "#{self.class}\##{__method__}")
      values = {
        column: column_name,
        value: values_or_value,
      }
    end
    parameter = FilterExpressionParameter.new(expression, values)
    add_parameter(FilterMerger, parameter)
  else
    message =
      "wrong number of arguments (given #{n_args}, expected 0..2)"
    raise ArgumentError, message
  end
end

#limit(value) ⇒ Object 



274
275
276
 
# File 'lib/groonga/client/request/select.rb', line 274

def limit(value)
  parameter(:limit, value)
end

#match_columns(values) ⇒ Object 



41
42
43
 
# File 'lib/groonga/client/request/select.rb', line 41

def match_columns(values)
  values_parameter([:match_columns], values)
end

#offset(value) ⇒ Object 



270
271
272
 
# File 'lib/groonga/client/request/select.rb', line 270

def offset(value)
  parameter(:offset, value)
end

#output_columns(value) ⇒ Object 



258
259
260
261
 
# File 'lib/groonga/client/request/select.rb', line 258

def output_columns(value)
  add_parameter(OverwriteMerger,
                OutputColumnsParameter.new("", value))
end

#paginate(page, per_page: 10) ⇒ Object 



278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/groonga/client/request/select.rb', line 278

def paginate(page, per_page: 10)
  page ||= 1
  page = page.to_i
  per_page = per_page.to_i
  per_page = 10 if per_page <= 0

  if page <= 0
    offset = 0
  else
    offset = per_page * (page - 1)
  end
  offset(offset).limit(per_page)
end

#query(value) ⇒ Object 



45
46
47
48
 
# File 'lib/groonga/client/request/select.rb', line 45

def query(value)
  add_parameter(QueryMerger,
                RequestParameter.new(:query, value))
end

#query_flags(flag) ⇒ Groonga::Client::Request::Select #query_flags(flags) ⇒ Groonga::Client::Request::Select

Sets flags to custom how to parse query.

Examples:

One flag

request.
  # Support "COLUMN_NAME:..." syntax
  query_flags("ALLOW_COLUMN").
    # -> --query_flags 'ALLOW_COLUMN'
  query("title:@Groonga")
    # -> --query_flags 'ALLOW_COLUMN'
    #    --query 'title:@Groonga'

Multiple flags

request.
  # Support "COLUMN_NAME:..." syntax
  # Fallback syntax error query to searchable query
  query_flags(["ALLOW_COLUMN", "QUERY_NO_SYNTAX_ERROR"]).
    # -> --query_flags 'ALLOW_COLUMN'
  query("nonexistent:@Groonga")
    # -> --query_flags 'ALLOW_COLUMN'
    #    --query 'nonexistent:@Groonga'
    # Normally, "nonexistent:@Groonga" is syntax error
    # but it's parsed as
    # "search by one keyword: 'nonexistent:@Groonga'"
    # because QUERY_NO_SYNTAX_ERROR flag is used

Overloads:

Returns:



94
95
96
 
# File 'lib/groonga/client/request/select.rb', line 94

def query_flags(value)
  flags_parameter(:query_flags, value)
end

#scorer(column_name) ⇒ Groonga::Client::Request::Select #scorer(expression, values = nil) ⇒ Groonga::Client::Request::Select

Sets scorer.

Overloads:

  • #scorer(column_name) ⇒ Groonga::Client::Request::Select

    Sets _score = #{column_name} scorer.

    Examples:

    Use column value as score

    request.scorer(:rate)
    # -> --scorer '_score = rate'

    Parameters:

    • column_name (Symbol) —

      The column name to be used as score.

  • #scorer(expression, values = nil) ⇒ Groonga::Client::Request::Select

    Adds a _score = #{expression % values} scorer. If expression is already assignment form such as _score = %{column}, _score = isn't prepended automatically.

    Examples:

    Compute score by expression

    request.scorer("2 * rate")
    # -> --scorer '_score = 2 * rate'

    Expand values

    request.scorer("2 * %{column}", column: :rate)
    # -> --scorer '_score = 2 * rate'

    Parameters:

    • expression (String) —

      The script syntax expression. It can includes %{name}s as placeholder. They are expanded by String#% with the given values argument.

    • values (nil, ::Hash) (defaults to: nil) —

      The values to be expanded. If the given expression doesn't have placeholder, you should specify nil.

      Values are escaped automatically. Values passed from external should be escaped.

Returns:

Since:

  • 0.5.1



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/groonga/client/request/select.rb', line 235

def scorer(expression_or_column_name, values=nil)
  case expression_or_column_name
  when Symbol
    expression = "_score = %{column}"
    column_name = expression_or_column_name
    values = { column: column_name }
  when String
    expression = expression_or_column_name
    case expression
    when /\A\s*\z/
      expression = nil
    when /\A[_a-zA-Z\d]+\s*=/
      # have assignment such as "_score = "
    else
      expression = "_score = #{expression}"
    end
  else
    expression = expression_or_column_name
  end
  add_parameter(OverwriteMerger,
                ScorerExpressionParameter.new(expression, values))
end

#sort_keys(value) ⇒ Object Also known as: sortby, sort 



263
264
265
266
 
# File 'lib/groonga/client/request/select.rb', line 263

def sort_keys(value)
  add_parameter(OverwriteMerger,
                BackwardCompatibleSortKeysParameter.new("", value))
end