class Audrey::Query::Q0

Audrey::Query::Q0

Attributes

aclass[RW]
db[R]
fields[RW]
limit[RW]
offset[RW]

Public Class Methods

new(p_db) click to toggle source
# File lib/audrey/query/q0.rb, line 14
def initialize(p_db)
        # check that we got a Audrey object
        if not p_db.is_a?(Audrey)
                raise 'db-not-audrey: ' + pdb.class.to_s
        end
        
        @db = p_db
        @engine = @db.engine
        @aclass = nil
        @fields = Audrey::Query::Q0::Fields.new()
end

Public Instance Methods

aclasses() click to toggle source
# File lib/audrey/query/q0.rb, line 157
def aclasses
        # $tm.hrm
        
        # early exit: no aclass
        if not @aclass
                return nil
        end
        
        # initialize
        fcs = [*@aclass]
        
        # early exit: aclass is an empty array
        # NOTE: An empty array would mean that not records are returned, so
        # we'll interpret it to mean all records.
        if not fcs.any?
                return nil
        end
        
        # initialize
        rv = {}
        
        # build aclasses
        fcs.each do |aclass|
                aclass.aclasses.each do |desc|
                        rv[desc] = nil
                end
        end
        
        # return
        return rv.keys
end
clone() click to toggle source
# File lib/audrey/query/q0.rb, line 196
def clone
        # $tm.hrm
        rv = self.class.new(@db)
        
        # aclass
        if @aclass.is_a?(Array)
                rv.aclass = @aclass.clone
        else
                rv.aclass = @aclass
        end
        
        # fields
        rv.fields = @fields.clone
        
        # return
        return rv
end
count() click to toggle source
# File lib/audrey/query/q0.rb, line 91
def count
        return @engine.q0(self).count
end
defined() click to toggle source
# File lib/audrey/query/q0.rb, line 146
def defined
        return Audrey::Query::Q0::Defined
end
each(opts={}) { |object_from_pk| ... } click to toggle source
# File lib/audrey/query/q0.rb, line 33
def each(opts={})
        # $tm.hrm
        equery = @engine.q0(self)
        
        # loop through equery results
        equery.each(opts) do |pk|
                yield @db.object_from_pk(pk)
        end
end
first() click to toggle source
# File lib/audrey/query/q0.rb, line 131
def first
        each() do |obj|
                return obj
        end
        
        return nil
end
iterator() click to toggle source
# File lib/audrey/query/q0.rb, line 221
def iterator
        # $tm.hrm
        return Audrey::Query::Q0::Iterator.new(self, @engine.q0(self).iterator)
end
sample() click to toggle source
# File lib/audrey/query/q0.rb, line 50
def sample
        # $tm.hrm
        cl = self.clone()
        cl.limit = 1
        cl.offset = rand(self.count)
        return cl.first
end
samples(count) click to toggle source
# File lib/audrey/query/q0.rb, line 68
def samples(count)
        rv = {}
        
        # loop until we get enough objects
        while rv.length < count
                obj = sample()
                
                if not rv[obj.audrey.pk]
                        rv[obj.audrey.pk] = obj
                end
        end
        
        # return
        return rv.values
end
sum(fname) click to toggle source
# File lib/audrey/query/q0.rb, line 102
def sum(fname)
        total = 0
        
        # optimize the query by cloning and add Defined
        qopt = self.clone
        qopt.fields.add 'calls', qopt.defined
        
        # loop through records
        qopt.run do |record|
                field = record.audrey[fname]
                
                if field.is_a?(Numeric)
                        total += field
                end
        end
        
        # return
        return total
end