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:

    • The target column name.

    • The column value. It's escaped automatically.

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

    Adds a #{expression % values} condition.

    Parameters:

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

    • (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:

    • The new request object for setting a filter condition.

    Since:

    • 0.4.3

Returns:

  • The new request with the given condition.



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:

  • The new request with the given flag.



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:

    • 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:

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

    • (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:

  • The new request with the given scorer.

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