class Groonga::Client::Request::Select

Public Class Methods

command_name() click to toggle source
# File lib/groonga/client/request/select.rb, line 24
def command_name
  "select"
end
new(table_or_parameters, extensions=[]) click to toggle source
Calls superclass method Groonga::Client::Request::Generic::new
# 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

Public Instance Methods

columns(label) click to toggle source
# File lib/groonga/client/request/select.rb, line 296
def columns(label)
  DynamicColumn.new(self, label)
end
drilldowns(label) click to toggle source
# File lib/groonga/client/request/select.rb, line 292
def drilldowns(label)
  LabeledDrilldown.new(self, label)
end
each(&block) click to toggle source
# File lib/groonga/client/request/select.rb, line 300
def each(&block)
  response.records.each(&block)
end
filter(*args) click to toggle source

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

@example Multiple filters

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

@return [Groonga::Client::Request::Select]

The new request with the given condition.

@overload filter(column_name, value)

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

@param column_name [Symbol] The target column name.

@param value [Object] The column value. It's escaped
  automatically.

@overload filter(expression, values=nil)

Adds a `#{expression % values}` condition.

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

@param values [nil, ::Hash] 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.

@overload filter

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

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

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

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

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

@return [Groonga::Client::Request::Select::Filter]
  The new request object for setting a filter condition.

@since 0.4.3
# 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) click to toggle source
# File lib/groonga/client/request/select.rb, line 274
def limit(value)
  parameter(:limit, value)
end
match_columns(values) click to toggle source
# File lib/groonga/client/request/select.rb, line 41
def match_columns(values)
  values_parameter([:match_columns], values)
end
offset(value) click to toggle source
# File lib/groonga/client/request/select.rb, line 270
def offset(value)
  parameter(:offset, value)
end
output_columns(value) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# File lib/groonga/client/request/select.rb, line 45
def query(value)
  add_parameter(QueryMerger,
                RequestParameter.new(:query, value))
end
query_flags(value) click to toggle source

Sets flags to custom how to parse query.

@example 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'

@example 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

@return [Groonga::Client::Request::Select]

The new request with the given flag.

@overload query_flags(flag)

Sets a `#{flag}` flag.

@param flag [String] The flag to be used.

@since 0.5.1

@overload query_flags(flags)

Sets `#{flag1}|#{flag2}|...` flags.

@param flags [::Array<String>] The flags to be used.

@since 0.5.1
# File lib/groonga/client/request/select.rb, line 94
def query_flags(value)
  flags_parameter(:query_flags, value)
end
scorer(expression_or_column_name, values=nil) click to toggle source

Sets scorer.

@return [Groonga::Client::Request::Select]

The new request with the given scorer.

@since 0.5.1

@overload scorer(column_name)

Sets `_score = #{column_name}` scorer.

@example Use column value as score
   request.scorer(:rate)
       # -> --scorer '_score = rate'

@param column_name [Symbol] The column name to be used as score.

@overload scorer(expression, values=nil)

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

@example Compute score by expression
   request.scorer("2 * rate")
       # -> --scorer '_score = 2 * rate'

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

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

@param values [nil, ::Hash] 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.
# 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(value)
Alias for: sort_keys
sort_keys(value) click to toggle source
# File lib/groonga/client/request/select.rb, line 263
def sort_keys(value)
  add_parameter(OverwriteMerger,
                BackwardCompatibleSortKeysParameter.new("", value))
end
Also aliased as: sortby, sort
sortby(value)
Alias for: sort_keys

Private Instance Methods

create_response() click to toggle source
# File lib/groonga/client/request/select.rb, line 305
def create_response
  response = super
  if paginated? and defined?(Kaminari)
    response.extend(Kaminari::ConfigurationMethods::ClassMethods)
    response.extend(Kaminari::PageScopeMethods)
  end
  response
end
paginated?() click to toggle source
# File lib/groonga/client/request/select.rb, line 314
def paginated?
  parameters = to_parameters
  parameters.key?(:offset) and parameters.key?(:limit)
end