Module: Spider::Model::Storage::Document::Mongodb::MapperExtension

Defined in:

lib/spiderfw/model/storage/document/adapters/mongodb.rb

Overview

Mapper extension

Instance Method Summary

• #fetch(query) ⇒ Object
• #postprocess_result(h, model = nil) ⇒ Object
• #prepare_condition(condition) ⇒ Object
• #prepare_request(request) ⇒ Object

Instance Method Details

#fetch(query) ⇒ Object

# File 'lib/spiderfw/model/storage/document/adapters/mongodb.rb', line 253

def fetch(query)
    condition = prepare_condition(query.condition)
    request = prepare_request(query.request)
    options = {}
    options[:limit] = query.limit if query.limit
    options[:skip] = query.offset if query.offset
    if query.order
        order_array = []
        query.order.each do |order|
            order_element, direction = order
            dir_str = direction == :desc ? 'descending' : 'ascending'
            order_array << [order_element.to_s, dir_str]
        end
        options[:sort] = order_array unless order_array.empty?
    end
    res = storage.find(@model.name, condition, request, options)
    r = res.map{ |row| postprocess_result(row) }
    r.extend(Storage::StorageResult) # FIXME: avoid doing this twice
    r.total_rows = res.total_rows
    r
end

#postprocess_result(h, model = nil) ⇒ Object

# File 'lib/spiderfw/model/storage/document/adapters/mongodb.rb', line 275

def postprocess_result(h, model=nil)
    model ||= @model
    sh = {}
    h.each do |k, v|
        if k == :_id
            pks = model.split_keys_string(v)
            model.primary_keys.each_with_index do |pk, i|
                pkval = pks[i]
                pkval = storage_value_to_mapper(pk.type, pkval)
                sh[pk.name] = pks[i]
            end
        else
            el = model.elements[k]
            v = if v.is_a?(Hash)
                postprocess_result(v, el.model)
            elsif v.is_a?(Array)
                v.map{ |row| postprocess_result(row, el.model) }
            else
                v
            end
            sh[k] = v
        end
    end
    sh
end

#prepare_condition(condition) ⇒ Object

# File 'lib/spiderfw/model/storage/document/adapters/mongodb.rb', line 172

def prepare_condition(condition)
    cond_hash = {}
    pks = []
    condition.each_with_comparison do |k, v, comp|
        element = model.elements[k.to_sym]
        name = nil
        if element.primary_key?
            if @model.primary_keys.length == 1
                name = '_id'
            else
                raise "Mongo conditions for multiple primary keys are not supported yet"
            end
        else
            name = element.name.to_s
        end
        #next unless model.mapper.mapped?(element)
        if element.model?
            if element.attributes[:embedded]
                # TODO
            else
                pks = []
                element.model.primary_keys.each do |ek|
                    kv = v[ek.name]
                    raise "Document mapper can't join #{element.name}: condition #{condition}" unless kv
                    pks << element.mapper.map_condition_value(ek.type, kv)
                end
                hash_v = element.model.keys_string(pks)
                hash_v = {Mongodb::CONDITION_OPS[comp] => hash_v} unless comp == '='
                cond_hash[name] = hash_v
            end
        else
            hash_v = map_condition_value(element.type, v)
            comp ||= '='
            if comp != '='
                if comp == 'like' || comp == 'ilike'
                    options = comp == 'ilike' ? Regexp::IGNORECASE : nil
                    parts = hash_v.split('%')
                    parts << "" if hash_v[-1].chr == '%'
                    re_str = parts.map{ |p| p.blank? ? '' : Regexp.quote(p)}.join('.+') 
                    hash_v = Regexp.new(re_str, options)
                else
                    hash_v = {Mongodb::CONDITION_OPS[comp] => hash_v}
                end
            end
            cond_hash[name] = hash_v
        end
    end
    or_conds = []
    or_conds << cond_hash if condition.conjunction == :or && condition.subconditions.length > 0
    condition.subconditions.each do |sub|
        sub_res = self.prepare_condition(sub)
        if condition.conjunction == :and
            cond_hash.merge!(sub_res)
        elsif condition.conjunction == :or
            or_conds << sub_res
        end
    end
    unless or_conds.empty?
        cond_hash = { '$or' => or_conds }
    end
    cond_hash
end

#prepare_request(request) ⇒ Object

# File 'lib/spiderfw/model/storage/document/adapters/mongodb.rb', line 235

def prepare_request(request)
    h = {}
    request.each do |k, v|
        element = @model.elements[k.to_sym]
        next unless element
        name = element.primary_key? ? '_id' : element.name.to_s
        if v.is_a?(Spider::Model::Request)
            sub = prepare_request(v)
            sub.each do |sk, sv|
                h["#{name}.#{sk}"] = sv
            end
        else
            h[name] = 1
        end
    end
    h
end