class Elastic::Query

Constants

DEFAULT_SORT

Attributes

fields[RW]
limit[RW]
offset[RW]
query_settings[RW]
sort[RW]

Public Class Methods

new(params = nil) click to toggle source
# File lib/co-elastic-query.rb, line 6
def initialize(params = nil)
    query = params ? params.permit(:q, :limit, :offset) : {}

    @filters = nil
    @search = "#{query[:q]}*"
    @fields = ['_all'.freeze]

    @limit = query[:limit] || 20
    @limit = @limit.to_i
    @limit = 10000 if @limit > 10000

    @offset = query[:offset] || 0
    @offset = offset.to_i
    @offset = 10000 if offset > 10000
end

Public Instance Methods

and_filter(filters) click to toggle source
# File lib/co-elastic-query.rb, line 51
def and_filter(filters)
    @andFilter ||= {}
    @andFilter.merge!(filters)
    self
end
build() click to toggle source
# File lib/co-elastic-query.rb, line 94
def build
    if @filters
        fieldfilters = []

        @filters.each do |key, value|
            fieldfilter = { :or => [] }
            build_filter(fieldfilter[:or], key, value)

            # TODO:: Discuss this - might be a security issue
            unless fieldfilter[:or].empty?
                fieldfilters.push(fieldfilter)
            end
        end
    end

    if @orFilter
        fieldfilters ||= []
        fieldfilter = { :or => [] }
        orArray = fieldfilter[:or]

        @orFilter.each do |key, value|
            build_filter(orArray, key, value)
        end

        unless orArray.empty?
            fieldfilters.push(fieldfilter)
        end
    end

    if @andFilter
        fieldfilters ||= []
        fieldfilter = { :and => [] }
        andArray = fieldfilter[:and]

        @andFilter.each do |key, value|
            build_filter(andArray, key, value)
        end

        unless andArray.empty?
            fieldfilters.push(fieldfilter)
        end
    end

    if @rangeFilter
        fieldfilters ||= []

        @rangeFilter.each do |value|
            fieldfilters.push({range: value})
        end
    end

    if @nots
        fieldfilters ||= []

        @nots.each do |key, value|
            fieldfilter = { not: { filter: { or: [] } } }
            build_filter(fieldfilter[:not][:filter][:or], key, value)
            unless fieldfilter[:not][:filter][:or].empty?
                fieldfilters.push(fieldfilter)
            end
        end
    end

    if @missing
        fieldfilters ||= []

        @missing.each do |field|
            fieldfilters.push({
                missing: { field: field }
            })
        end
    end

    if @exists
        fieldfilters ||= []

        @exists.each do |field|
            fieldfilters.push({
                exists: { field: field }
            })
        end
    end

    if @raw_filter
        fieldfilters ||= []
        fieldfilters += @raw_filter
    end

    if @search.length > 1
        # Break the terms up purely on whitespace
        query_obj = nil

        if @hasChild || @hasParent
            should = [{
                    simple_query_string: {
                        query: @search,
                        fields: @fields
                    }
                }]

            if @query_settings
                should[0][:simple_query_string].merge! @query_settings
            end

            if @hasChild
                should << {
                        has_child: {
                            type: @hasChild,
                            query: {
                                simple_query_string: {
                                    query: @search,
                                    fields: @fields
                                }
                            }
                        }
                    }
            end

            if @hasParent
                should << {
                        has_parent: {
                            parent_type: @hasParent,
                            query: {
                                simple_query_string: {
                                    query: @search,
                                    fields: @fields
                                }
                            }
                        }
                    }
            end

            query_obj = {
                query: {
                    bool: {
                        should: should
                    }
                },
                filters: fieldfilters,
                offset: @offset,
                limit: @limit
            }
        else
            query_obj = {
                query: {
                    simple_query_string: {
                        query: @search,
                        fields: @fields
                    }
                },
                filters: fieldfilters,
                offset: @offset,
                limit: @limit
            }
        end

        query_obj
    else
        {
            sort: @sort || DEFAULT_SORT,
            filters: fieldfilters,
            query: {
                match_all: {}
            },
            offset: @offset,
            limit: @limit
        }
    end
end
build_filter(filters, key, values) click to toggle source

protected

# File lib/co-elastic-query.rb, line 274
def build_filter(filters, key, values)
    values.each { |var|
        if var.nil?
            filters.push({
                missing: { field: key }
            })
        else
            filters.push({
                :term => {
                    key => var
                }
            })
        end
    }
end
exists(*fields) click to toggle source
# File lib/co-elastic-query.rb, line 87
def exists(*fields)
    @exists ||= Set.new
    @exists.merge(fields)
    self
end
filter(filters) click to toggle source

filters is in the form {fieldname1: ['var1','var2',…], fieldname2: ['var1','var2'…]}

NOTE

may overwrite an existing filter in merge

# File lib/co-elastic-query.rb, line 38
def filter(filters)
    @filters ||= {}
    @filters.merge!(filters)
    self
end
has_child(name) click to toggle source

Applys the query to child objects

# File lib/co-elastic-query.rb, line 58
def has_child(name)
    @hasChild = name
end
has_parent(name) click to toggle source
# File lib/co-elastic-query.rb, line 62
def has_parent(name)
    @hasParent = name
end
missing(*fields) click to toggle source

Call to add fields that should be missing Effectively adds a filter that ensures a field is missing

# File lib/co-elastic-query.rb, line 74
def missing(*fields)
    @missing ||= Set.new
    @missing.merge(fields)
    self
end
not(filters) click to toggle source

The opposite of filter

# File lib/co-elastic-query.rb, line 81
def not(filters)
    @nots ||= {}
    @nots.merge!(filters)
    self
end
or_filter(filters) click to toggle source

Like filter however all keys are OR's instead of AND's

# File lib/co-elastic-query.rb, line 45
def or_filter(filters)
    @orFilter ||= {}
    @orFilter.merge!(filters)
    self
end
range(filter) click to toggle source
# File lib/co-elastic-query.rb, line 66
def range(filter)
    @rangeFilter ||= []
    @rangeFilter << filter
    self
end
raw_filter(filter) click to toggle source
# File lib/co-elastic-query.rb, line 25
def raw_filter(filter)
    @raw_filter ||= []
    @raw_filter << filter
    self
end
search_field(field) click to toggle source
# File lib/co-elastic-query.rb, line 31
def search_field(field)
    @fields.unshift(field)
end