Class: InterMine::PathQuery::Template

Inherits:
Query
  • Object
show all
Defined in:
lib/intermine/query.rb

Constant Summary

Constants inherited from Query

Query::HIGHEST_CODE, Query::LOWEST_CODE

Instance Attribute Summary collapse

Attributes inherited from Query

#constraints, #joins, #list_append_uri, #list_upload_uri, #logic, #model, #name, #root, #service, #size, #sort_order, #start, #title, #views

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Query

#add_constraint, #add_join, #add_prefix, #add_sort_order, #add_views, #all, #all_rows, #coded_constraints, #eql?, #first, #first_row, #get_constraint, #inspect, is_valid_code, #limit, #make_path, #next_code, #offset, #outerjoin, #path, #remove_constraint, #results_reader, #set_logic, #sortOrder=, #subclass_constraints, #subclasses, #to_s, #used_codes, #view=, #where

Constructor Details

#initialize(model, root = nil, service = nil) ⇒ Template

Returns a new instance of Template.



1613
1614
1615
1616
1617
 
# File 'lib/intermine/query.rb', line 1613

def initialize(model, root=nil, service=nil)
    super
    @constraint_factory = TemplateConstraintFactory.new(self)
    @url = (@service.nil?) ? nil : @service.root + Service::TEMPLATE_RESULTS_PATH
end

Instance Attribute Details

#comment ⇒ Object

Returns the value of attribute comment.



1611
1612
1613
 
# File 'lib/intermine/query.rb', line 1611

def comment
  @comment
end

#longDescription ⇒ Object

Returns the value of attribute longDescription.



1611
1612
1613
 
# File 'lib/intermine/query.rb', line 1611

def longDescription
  @longDescription
end

Class Method Details

.parser(model) ⇒ Object 



1619
1620
1621
 
# File 'lib/intermine/query.rb', line 1619

def self.parser(model)
    return TemplateLoader.new(model)
end

Instance Method Details

#active_constraints ⇒ Object 



1634
1635
1636
 
# File 'lib/intermine/query.rb', line 1634

def active_constraints
    return coded_constraints.select {|con| con.switchable != "off"}
end

#clone ⇒ Object

Return a clone of the current template. Changes made to the clone will not effect the cloned query.



1750
1751
1752
1753
1754
 
# File 'lib/intermine/query.rb', line 1750

def clone
    other = super
    other.instance_variable_set(:@constraints, @constraints.map {|c| c.clone})
    return other
end

#count(params = {}) ⇒ Object

Return the number of result rows this query will return in its current state. This makes a very small request to the webservice, and is the most efficient method of getting the size of the result set.



1743
1744
1745
1746
 
# File 'lib/intermine/query.rb', line 1743

def count(params = {})
    runner = (params.empty?) ? self : get_adjusted(params)
    runner.results_reader.get_size
end

#each_result(params = {}, start = 0, size = nil) ⇒ Object 



1693
1694
1695
1696
 
# File 'lib/intermine/query.rb', line 1693

def each_result(params = {}, start=0, size=nil) 
    runner = (params.empty?) ? self : get_adjusted(params)
    runner.results_reader(start, size).each_result {|r| yield r}
end

#each_row(params = {}, start = 0, size = nil) ⇒ Object 



1675
1676
1677
1678
 
# File 'lib/intermine/query.rb', line 1675

def each_row(params = {}, start=0, size=nil)
    runner = (params.empty?) ? self : get_adjusted(params)
    runner.results_reader(start, size).each_row {|r| yield r}
end

#editable_constraints ⇒ Object 



1630
1631
1632
 
# File 'lib/intermine/query.rb', line 1630

def editable_constraints
    return coded_constraints.select {|con| con.editable}
end

#params ⇒ Object 



1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
 
# File 'lib/intermine/query.rb', line 1638

def params 
    p = {"name" => @name}
    actives = active_constraints
    actives.each_index do |idx|
        con = actives[idx]
        count = (idx + 1).to_s
        p["constraint" + count] = con.path.to_s
        p["op" + count] = con.template_param_op
        if con.respond_to? :value
            p["value" + count] = con.value
        elsif con.respond_to? :values
            p["value" + count] = con.values
        elsif con.respond_to? :loopPath
            p["loopPath" + count] = con.loopPath.to_s
        end
        if con.respond_to? :extra_value and !con.extra_value.nil?
            p["extra" + count] = con.extra_value
        end
    end
    return p
end

#results(params = {}, start = 0, size = nil) ⇒ Object

Return objects corresponding to the type of data requested, starting at the given row offset. Returns an Enumerable of InterMineObject, where each value is read one at a time from the connection. 

template.results("A" => "eve").each {|gene|
    puts gene.symbol
}



1688
1689
1690
1691
 
# File 'lib/intermine/query.rb', line 1688

def results(params = {}, start=0, size=nil)
    runner = (params.empty?) ? self : get_adjusted(params)
    return self.class.superclass.instance_method(:results).bind(runner).call(start, size)
end

#rows(params = {}, start = 0, size = nil) ⇒ Object

Returns an Enumerable of ResultRow objects containing the data returned by running this query, starting at the given offset and containing up to the given maximum size.

The webservice enforces a maximum page-size of 10,000,000 rows, independent of any size you specify - this can be obviated with paging for large result sets.

names = template.rows("A" => "eve").map {|r| r["name"]}



1670
1671
1672
1673
 
# File 'lib/intermine/query.rb', line 1670

def rows(params = {}, start=0, size=nil)
    runner = (params.empty?) ? self : get_adjusted(params)
    return self.class.superclass.instance_method(:rows).bind(runner).call(start, size)
end

#summaries(path, params = {}, start = 0, size = nil) ⇒ Object

Return an Enumerable of summary items starting at the given offset.

summary = template.summary_items("chromosome.primaryIdentifier", {"A" => "Pentose Phosphate Pathway"})
top_chromosome = summary[0]["item"]
no_in_top_chrom = summary[0]["count"]

This can be made more efficient by passing in a size - ie, if you only want the top item, pass in an offset of 0 and a size of 1 and only that row will be fetched.



1708
1709
1710
1711
 
# File 'lib/intermine/query.rb', line 1708

def summaries(path, params = {}, start=0, size=nil)
    runner = (params.empty?) ? self : get_adjusted(params)
    return self.class.superclass.instance_method(:summaries).bind(runner).call(path, start, size)
end

#summarise(path, params = {}, start = 0, size = nil) ⇒ Object

Return a summary for a column as a Hash

For numeric values the hash has four keys: “average”, “stdev”, “min”, and “max”. 

summary = template.summarise("length", {"A" => "eve"})
puts summary["average"]

For non-numeric values, the hash will have each possible value as a key, and the count of the occurrences of that value in this query’s result set as the corresponding value:

summary = template.summarise("chromosome.primaryIdentifier", {"A" => "eve"})
puts summary["2L"]

To limit the size of the result set you can use start and size as per normal queries - this has no real effect with numeric queries, which always return the same information.



1731
1732
1733
1734
1735
1736
1737
1738
 
# File 'lib/intermine/query.rb', line 1731

def summarise(path, params={}, start=0, size=nil)
    t = make_path(add_prefix(path)).end_type
    if InterMine::Metadata::Model::NUMERIC_TYPES.include? t
        return Hash[summaries(path, params, start, size).first.map {|k, v| [k, v.to_f]}]
    else
        return Hash[summaries(path, params, start, size).map {|sum| [sum["item"], sum["count"]]}]
    end
end

#to_xml ⇒ Object 



1623
1624
1625
1626
1627
1628
 
# File 'lib/intermine/query.rb', line 1623

def to_xml
    doc = REXML::Document.new
    t = doc.add_element 'template', {"name" => @name, "title" => @title, "longDescription" => @longDescription, "comment" => @comment}.reject {|k,v| v.nil?}
    t.add_element super
    return t
end