class LC::Query

Attributes

class_name[RW]
count[RW]
include[RW]
limit[RW]
order[RW]
order_by[RW]
skip[RW]
where[RW]

Public Class Methods

do_cloud_query(cql, pvalues=[]) click to toggle source
# File lib/leancloud/query.rb, line 15
def self.do_cloud_query(cql, pvalues=[])
  uri   = Protocol.cql_uri
  query = { "cql" => cql,"pvalues"=> pvalues.to_json }
  LC.client.logger.info{"Leancloud query for #{uri} #{query.inspect}"} unless LC.client.quiet
  response = LC.client.request uri, :get, nil, query

  if response.is_a?(Hash) && response.has_key?(Protocol::KEY_RESULTS) && response[Protocol::KEY_RESULTS].is_a?(Array)
    class_name = response[Protocol::KEY_CLASS_NAME]
    parsed_results = response[Protocol::KEY_RESULTS].map{|o| LC.parse_json(class_name, o)}
    return {
        count: response['count'],
        results: parsed_results
    }
  else
    raise LCError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
  end
end
new(cls_name) click to toggle source
# File lib/leancloud/query.rb, line 33
def initialize(cls_name)
  @class_name = cls_name
  @where = {}
  @order = :ascending
  @ors = []
end

Public Instance Methods

add_constraint(field, constraint) click to toggle source
# File lib/leancloud/query.rb, line 40
def add_constraint(field, constraint)
  raise ArgumentError, "cannot add constraint to an $or query" if @ors.size > 0
  current = where[field]
  if current && current.is_a?(Hash) && constraint.is_a?(Hash)
    current.merge! constraint
  else
    where[field] = constraint
  end
end
contains_all(field, values) click to toggle source
# File lib/leancloud/query.rb, line 113
def contains_all(field, values)
  add_constraint field, { "$all" => values.map { |v| LC.pointerize_value(v) } }
  self
end
eq(hash_or_field,value=nil) click to toggle source
# File lib/leancloud/query.rb, line 62
def eq(hash_or_field,value=nil)
  return eq_pair(hash_or_field,value) unless hash_or_field.is_a?(Hash)
  hash_or_field.each_pair { |k,v| eq_pair k, v }
  self
end
eq_pair(field, value) click to toggle source
# File lib/leancloud/query.rb, line 68
def eq_pair(field, value)
  add_constraint field, LC.pointerize_value(value)
  self
end
exists(field, value = true) click to toggle source
# File lib/leancloud/query.rb, line 123
def exists(field, value = true)
  add_constraint field, { "$exists" => value }
  self
end
first() click to toggle source
# File lib/leancloud/query.rb, line 147
def first
  self.limit = 1
  get.first
end
get() click to toggle source
# File lib/leancloud/query.rb, line 152
def get
  uri   = Protocol.class_uri @class_name
  if @class_name == LC::Protocol::CLASS_USER
    uri = Protocol.user_uri
  elsif @class_name == LC::Protocol::CLASS_INSTALLATION
    uri = Protocol.installation_uri
  end
  query = { "where" => where_as_json.to_json }
  set_order(query)
  [:count, :limit, :skip, :include].each {|a| merge_attribute(a, query)}
  LC.client.logger.info{"Parse query for #{uri} #{query.inspect}"} unless LC.client.quiet
  response = LC.client.request uri, :get, nil, query

  if response.is_a?(Hash) && response.has_key?(Protocol::KEY_RESULTS) && response[Protocol::KEY_RESULTS].is_a?(Array)
    parsed_results = response[Protocol::KEY_RESULTS].map{|o| LC.parse_json(class_name, o)}
    if response.keys.size == 1
      parsed_results
    else
      response.dup.merge(Protocol::KEY_RESULTS => parsed_results)
    end
  else
    raise LCError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
  end
end
greater_eq(field, value) click to toggle source
# File lib/leancloud/query.rb, line 98
def greater_eq(field, value)
  add_constraint field, { "$gte" => LC.pointerize_value(value) }
  self
end
greater_than(field, value) click to toggle source
# File lib/leancloud/query.rb, line 93
def greater_than(field, value)
  add_constraint field, { "$gt" => LC.pointerize_value(value) }
  self
end
in_query(field, query=nil) click to toggle source
# File lib/leancloud/query.rb, line 128
def in_query(field, query=nil)
  query_hash = {LC::Protocol::KEY_CLASS_NAME => query.class_name, "where" => query.where}
  add_constraint(field, "$inQuery" => query_hash)
  self
end
includes(class_name) click to toggle source

private :add_constraint

# File lib/leancloud/query.rb, line 51
def includes(class_name)
  @includes = class_name
  self
end
less_eq(field, value) click to toggle source
# File lib/leancloud/query.rb, line 88
def less_eq(field, value)
  add_constraint field, { "$lte" => LC.pointerize_value(value) }
  self
end
less_than(field, value) click to toggle source
# File lib/leancloud/query.rb, line 83
def less_than(field, value)
  add_constraint field, { "$lt" => LC.pointerize_value(value) }
  self
end
not_eq(field, value) click to toggle source
# File lib/leancloud/query.rb, line 73
def not_eq(field, value)
  add_constraint field, { "$ne" => LC.pointerize_value(value) }
  self
end
or(query) click to toggle source
# File lib/leancloud/query.rb, line 56
def or(query)
  raise ArgumentError, "you must pass an entire #{self.class} to \#or" unless query.is_a?(self.class)
  @ors << query
  self
end
regex(field, expression) click to toggle source
# File lib/leancloud/query.rb, line 78
def regex(field, expression)
  add_constraint field, { "$regex" => expression }
  self
end
value_in(field, values) click to toggle source
# File lib/leancloud/query.rb, line 103
def value_in(field, values)
  add_constraint field, { "$in" => values.map { |v| LC.pointerize_value(v) } }
  self
end
value_not_in(field, values) click to toggle source
# File lib/leancloud/query.rb, line 108
def value_not_in(field, values)
  add_constraint field, { "$nin" => values.map { |v| LC.pointerize_value(v) } }
  self
end
where_as_json() click to toggle source
# File lib/leancloud/query.rb, line 139
def where_as_json
  if @ors.size > 0
    {"$or" => [self.where] + @ors.map{|query| query.where_as_json}}
  else
    @where
  end
end

Private Instance Methods

merge_attribute(attribute, query, query_field = nil) click to toggle source
# File lib/leancloud/query.rb, line 186
def merge_attribute(attribute, query, query_field = nil)
  value = self.instance_variable_get("@#{attribute.to_s}")
  return if value.nil?
  query.merge!((query_field || attribute) => value)
end
set_order(query) click to toggle source
# File lib/leancloud/query.rb, line 179
def set_order(query)
  return unless @order_by
  order_string = @order_by
  order_string = "-#{order_string}" if @order == :descending
  query.merge!(:order => order_string)
end