Class: SPARQL::Client::Query
- Inherits:
-
RDF::Query
- Object
- RDF::Query
- SPARQL::Client::Query
- Defined in:
- lib/sparql/client/query.rb
Overview
A SPARQL query builder.
Defined Under Namespace
Classes: Filter, WhereDecorator
Instance Attribute Summary collapse
-
#form ⇒ :select, ...
readonly
The form of the query.
- #options ⇒ Hash{Symbol => Object} readonly
Class Method Summary collapse
-
.ask(**options) ⇒ Query
Creates a boolean ‘ASK` query.
-
.self.construct(*variables, **options) ⇒ Query
Creates a graph ‘CONSTRUCT` query.
-
.self.describe(*variables, **options) ⇒ Query
Creates a ‘DESCRIBE` query.
-
.self.select(*variables, **options) ⇒ Query
Creates a tuple ‘SELECT` query.
Instance Method Summary collapse
- #asc(var) ⇒ Query
- #ask ⇒ Query
- #build_patterns(patterns) ⇒ Object
- #construct(*patterns) ⇒ Query
- #desc(var) ⇒ Query
- #describe(*variables) ⇒ Query
- #distinct(state = true) ⇒ Query
-
#each_solution {|solution| ... } ⇒ Enumerator
Enumerates over each matching query solution.
- #each_statement {|statement| ... } ⇒ Enumerator
- #execute ⇒ Object
-
#expects_statements? ⇒ Boolean
Expects_statements?.
- #false? ⇒ Boolean
- #filter(string) ⇒ Query
- #from(uri) ⇒ Query
- #graph(graph_uri_or_var) ⇒ Query
- #group(*variables) ⇒ Query (also: #group_by)
-
#self.construct(*variables, **options) ⇒ Query
constructor
A new instance of Query.
-
#inspect ⇒ String
Returns a developer-friendly representation of this query.
-
#inspect! ⇒ void
Outputs a developer-friendly representation of this query to ‘stderr`.
- #limit(length) ⇒ Query
-
#minus(*patterns) {|query| ... } ⇒ Query
The block form can be used for more complicated queries, using the ‘select` form (note, use either block or argument forms, not both):.
- #offset(start) ⇒ Query
-
#optional(*patterns) {|query| ... } ⇒ Query
The block form can be used for adding filters:.
- #order(*variables) ⇒ Query (also: #order_by)
- #prefix(val) ⇒ Object
- #reduced(state = true) ⇒ Query
- #result ⇒ Object
- #select(*variables) ⇒ Query
- #slice(start, length) ⇒ Query
- #solutions ⇒ Enumerable<RDF::Query::Solution>
-
#to_s ⇒ String
Returns the string representation of this query.
-
#to_s_ggp ⇒ Object
Serialize a Group Graph Pattern.
- #true? ⇒ Boolean
-
#union(*patterns) {|query| ... } ⇒ Query
The block form can be used for more complicated queries, using the ‘select` form (note, use either block or argument forms, not both):.
-
#values(*args) ⇒ Object
Specify inline data for a query.
-
#where(*patterns_queries) {|query| ... } ⇒ Query
(also: #whether)
Block form can be used for chaining calls in addition to creating sub-select queries.
Constructor Details
#self.construct(*variables, **options) ⇒ Query
Returns a new instance of Query.
106 107 108 109 110 |
# File 'lib/sparql/client/query.rb', line 106 def initialize(form = :ask, **, &block) @subqueries = [] @form = form.respond_to?(:to_sym) ? form.to_sym : form.to_s.to_sym super([], **, &block) end |
Instance Attribute Details
#form ⇒ :select, ... (readonly)
The form of the query.
16 17 18 |
# File 'lib/sparql/client/query.rb', line 16 def form @form end |
#options ⇒ Hash{Symbol => Object} (readonly)
20 21 22 |
# File 'lib/sparql/client/query.rb', line 20 def @options end |
Class Method Details
.ask(**options) ⇒ Query
Creates a boolean ‘ASK` query.
31 32 33 |
# File 'lib/sparql/client/query.rb', line 31 def self.ask(**) self.new(:ask, **) end |
.self.construct(*variables, **options) ⇒ Query
Creates a graph ‘CONSTRUCT` query.
91 92 93 |
# File 'lib/sparql/client/query.rb', line 91 def self.construct(*patterns, **) self.new(:construct, **).construct(*patterns) # FIXME end |
.self.describe(*variables, **options) ⇒ Query
Creates a ‘DESCRIBE` query.
73 74 75 |
# File 'lib/sparql/client/query.rb', line 73 def self.describe(*variables, **) self.new(:describe, **).describe(*variables) end |
.self.select(*variables, **options) ⇒ Query
Creates a tuple ‘SELECT` query.
55 56 57 |
# File 'lib/sparql/client/query.rb', line 55 def self.select(*variables, **) self.new(:select, **).select(*variables) end |
Instance Method Details
#asc(var) ⇒ Query
266 267 268 269 |
# File 'lib/sparql/client/query.rb', line 266 def asc(var) ([:order_by] ||= []) << {var => :asc} self end |
#ask ⇒ Query
118 119 120 121 |
# File 'lib/sparql/client/query.rb', line 118 def ask @form = :ask self end |
#build_patterns(patterns) ⇒ Object
623 624 625 |
# File 'lib/sparql/client/query.rb', line 623 def build_patterns(patterns) patterns.map {|pattern| RDF::Query::Pattern.from(pattern)} end |
#construct(*patterns) ⇒ Query
166 167 168 169 |
# File 'lib/sparql/client/query.rb', line 166 def construct(*patterns) [:template] = build_patterns(patterns) self end |
#desc(var) ⇒ Query
279 280 281 282 |
# File 'lib/sparql/client/query.rb', line 279 def desc(var) ([:order_by] ||= []) << {var => :desc} self end |
#describe(*variables) ⇒ Query
152 153 154 155 156 157 |
# File 'lib/sparql/client/query.rb', line 152 def describe(*variables) @values = variables.map { |var| [var, var.is_a?(RDF::URI) ? var : RDF::Query::Variable.new(var)] } self end |
#distinct(state = true) ⇒ Query
304 305 306 307 |
# File 'lib/sparql/client/query.rb', line 304 def distinct(state = true) [:distinct] = state self end |
#each_solution {|solution| ... } ⇒ Enumerator
Enumerates over each matching query solution.
672 673 674 675 |
# File 'lib/sparql/client/query.rb', line 672 def each_solution(&block) @solutions = result super end |
#each_statement {|statement| ... } ⇒ Enumerator
663 664 665 |
# File 'lib/sparql/client/query.rb', line 663 def each_statement(&block) result.each_statement(&block) end |
#execute ⇒ Object
685 686 687 |
# File 'lib/sparql/client/query.rb', line 685 def execute raise NotImplementedError end |
#expects_statements? ⇒ Boolean
Returns expects_statements?.
617 618 619 |
# File 'lib/sparql/client/query.rb', line 617 def expects_statements? [:construct, :describe].include?(form) end |
#false? ⇒ Boolean
649 650 651 |
# File 'lib/sparql/client/query.rb', line 649 def false? !true? end |
#filter(string) ⇒ Query
631 632 633 634 |
# File 'lib/sparql/client/query.rb', line 631 def filter(string) (([:filters] ||= []) << Filter.new(string)) if string and not string.empty? self end |
#from(uri) ⇒ Query
178 179 180 181 |
# File 'lib/sparql/client/query.rb', line 178 def from(uri) [:from] = uri self end |
#graph(graph_uri_or_var) ⇒ Query
326 327 328 329 330 331 332 333 334 |
# File 'lib/sparql/client/query.rb', line 326 def graph(graph_uri_or_var) [:graph] = case graph_uri_or_var when Symbol then RDF::Query::Variable.new(graph_uri_or_var) when String then RDF::URI(graph_uri_or_var) when RDF::Value then graph_uri_or_var else raise ArgumentError end self end |
#group(*variables) ⇒ Query Also known as: group_by
291 292 293 294 |
# File 'lib/sparql/client/query.rb', line 291 def group(*variables) [:group_by] = variables self end |
#inspect ⇒ String
Returns a developer-friendly representation of this query.
836 837 838 |
# File 'lib/sparql/client/query.rb', line 836 def inspect sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, to_s) end |
#inspect! ⇒ void
This method returns an undefined value.
Outputs a developer-friendly representation of this query to ‘stderr`.
827 828 829 830 |
# File 'lib/sparql/client/query.rb', line 827 def inspect! warn(inspect) self end |
#limit(length) ⇒ Query
354 355 356 |
# File 'lib/sparql/client/query.rb', line 354 def limit(length) slice(nil, length) end |
#minus(*patterns) {|query| ... } ⇒ Query
The block form can be used for more complicated queries, using the ‘select` form (note, use either block or argument forms, not both):
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 |
# File 'lib/sparql/client/query.rb', line 525 def minus(*patterns, &block) [:minuses] ||= [] if block_given? raise ArgumentError, "#minus requires either arguments or a block, not both." unless patterns.empty? # Evaluate calls in a new query instance query = self.class.select case block.arity when 1 then block.call(query) else query.instance_eval(&block) end [:minuses] << query elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)} # With argument form, all must be patterns or queries [:minuses] += patterns elsif patterns.all? {|p| p.is_a?(Array)} # With argument form, all must be patterns, or queries [:minuses] << self.class.select.where(*patterns) else raise ArgumentError, "#minus arguments are triple patters or queries, not both." end self end |
#offset(start) ⇒ Query
343 344 345 |
# File 'lib/sparql/client/query.rb', line 343 def offset(start) slice(start, nil) end |
#optional(*patterns) {|query| ... } ⇒ Query
The block form can be used for adding filters:
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 |
# File 'lib/sparql/client/query.rb', line 426 def optional(*patterns, &block) ([:optionals] ||= []) << build_patterns(patterns) if block_given? # Steal options[:filters] query_filters = [:filters] [:filters] = [] case block.arity when 1 then block.call(self) else instance_eval(&block) end [:optionals].last.concat([:filters]) [:filters] = query_filters end self end |
#order(*variables) ⇒ Query Also known as: order_by
251 252 253 254 |
# File 'lib/sparql/client/query.rb', line 251 def order(*variables) [:order_by] = variables self end |
#prefix(prefix: uri) ⇒ Query #prefix(string) ⇒ Query
393 394 395 396 397 398 399 400 401 402 403 404 405 |
# File 'lib/sparql/client/query.rb', line 393 def prefix(val) [:prefixes] ||= [] if val.kind_of? String [:prefixes] << val elsif val.kind_of? Hash val.each do |k, v| [:prefixes] << "#{k}: <#{v}>" end else raise ArgumentError, "prefix must be a kind of String or a Hash" end self end |
#reduced(state = true) ⇒ Query
315 316 317 318 |
# File 'lib/sparql/client/query.rb', line 315 def reduced(state = true) [:reduced] = state self end |
#result ⇒ Object
679 680 681 |
# File 'lib/sparql/client/query.rb', line 679 def result @result ||= execute end |
#select(*variables) ⇒ Query
136 137 138 139 140 141 142 143 |
# File 'lib/sparql/client/query.rb', line 136 def select(*variables) @values = if variables.length == 1 && variables.first.is_a?(Hash) variables.to_a else variables.map { |var| [var, RDF::Query::Variable.new(var)] } end self end |
#slice(start, length) ⇒ Query
365 366 367 368 369 |
# File 'lib/sparql/client/query.rb', line 365 def slice(start, length) [:offset] = start.to_i if start [:limit] = length.to_i if length self end |
#solutions ⇒ Enumerable<RDF::Query::Solution>
655 656 657 |
# File 'lib/sparql/client/query.rb', line 655 def solutions result end |
#to_s ⇒ String
Returns the string representation of this query.
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 |
# File 'lib/sparql/client/query.rb', line 693 def to_s buffer = [form.to_s.upcase] case form when :select, :describe only_count = values.empty? && [:count] buffer << 'DISTINCT' if [:distinct] and not only_count buffer << 'REDUCED' if [:reduced] buffer << ((values.empty? and not [:count]) ? '*' : values.map { |v| SPARQL::Client.serialize_value(v[1]) }.join(' ')) if [:count] [:count].each do |var, count| buffer << '( COUNT(' + ([:distinct] ? 'DISTINCT ' : '') + (var.is_a?(String) ? var : "?#{var}") + ') AS ' + (count.is_a?(String) ? count : "?#{count}") + ' )' end end when :construct buffer << '{' buffer += SPARQL::Client.serialize_patterns([:template]) buffer << '}' end buffer << "FROM #{SPARQL::Client.serialize_value([:from])}" if [:from] unless patterns.empty? && form == :describe buffer += self.to_s_ggp.unshift('WHERE') end .fetch(:unions, []).each do |query| buffer += query.to_s_ggp.unshift('UNION') end if [:group_by] buffer << 'GROUP BY' buffer += [:group_by].map { |var| var.is_a?(String) ? var : "?#{var}" } end if [:order_by] buffer << 'ORDER BY' [:order_by].map { |elem| case elem # .order_by({ var1: :asc, var2: :desc}) when Hash elem.each { |key, val| # check provided values if !key.is_a?(Symbol) raise ArgumentError, 'keys of hash argument must be a Symbol' elsif !val.is_a?(Symbol) || (val != :asc && val != :desc) raise ArgumentError, 'values of hash argument must either be `:asc` or `:desc`' end buffer << "#{val == :asc ? 'ASC' : 'DESC'}(?#{key})" } # .order_by([:var1, :asc], [:var2, :desc]) when Array # check provided values if elem.length != 2 raise ArgumentError, 'array argument must specify two elements' elsif !elem[0].is_a?(Symbol) raise ArgumentError, '1st element of array argument must contain a Symbol' elsif !elem[1].is_a?(Symbol) || (elem[1] != :asc && elem[1] != :desc) raise ArgumentError, '2nd element of array argument must either be `:asc` or `:desc`' end buffer << "#{elem[1] == :asc ? 'ASC' : 'DESC'}(?#{elem[0]})" # .order_by(:var1, :var2) when Symbol buffer << "?#{elem}" # .order_by('ASC(?var1) DESC(?var2)') when String buffer << elem else raise ArgumentError, 'argument provided to `order()` must either be an Array, Symbol or String' end } end buffer << "OFFSET #{[:offset]}" if [:offset] buffer << "LIMIT #{[:limit]}" if [:limit] [:prefixes].reverse.each { |e| buffer.unshift("PREFIX #{e}") } if [:prefixes] buffer.join(' ') end |
#to_s_ggp ⇒ Object
Serialize a Group Graph Pattern
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 |
# File 'lib/sparql/client/query.rb', line 776 def to_s_ggp buffer = ["{"] if [:graph] buffer << 'GRAPH ' + SPARQL::Client.serialize_value([:graph]) buffer << '{' end @subqueries.each do |sq| buffer << "{ #{sq.to_s} } ." end buffer += SPARQL::Client.serialize_patterns(patterns) if [:optionals] [:optionals].each do |patterns| buffer << 'OPTIONAL {' buffer += SPARQL::Client.serialize_patterns(patterns) buffer << '}' end end if [:filters] buffer += [:filters].map(&:to_s) end if [:values] vars = [:values].first.map {|var| SPARQL::Client.serialize_value(var)} buffer << "VALUES (#{vars.join(' ')}) {" [:values][1..-1].each do |data_block_value| buffer << '(' buffer << data_block_value.map do |value| value.nil? ? 'UNDEF' : SPARQL::Client.serialize_value(value) end.join(' ') buffer << ')' end buffer << '}' end if [:graph] buffer << '}' # GRAPH end .fetch(:minuses, []).each do |query| buffer += query.to_s_ggp.unshift('MINUS') end buffer << '}' buffer end |
#true? ⇒ Boolean
638 639 640 641 642 643 644 645 |
# File 'lib/sparql/client/query.rb', line 638 def true? case result when TrueClass, FalseClass then result when RDF::Literal::Boolean then result.true? when Enumerable then !result.empty? else false end end |
#union(*patterns) {|query| ... } ⇒ Query
The block form can be used for more complicated queries, using the ‘select` form (note, use either block or argument forms, not both):
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 |
# File 'lib/sparql/client/query.rb', line 472 def union(*patterns, &block) [:unions] ||= [] if block_given? raise ArgumentError, "#union requires either arguments or a block, not both." unless patterns.empty? # Evaluate calls in a new query instance query = self.class.select case block.arity when 1 then block.call(query) else query.instance_eval(&block) end [:unions] << query elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)} # With argument form, all must be patterns or queries [:unions] += patterns elsif patterns.all? {|p| p.is_a?(Array)} # With argument form, all must be patterns, or queries [:unions] << self.class.select.where(*patterns) else raise ArgumentError, "#union arguments are triple patters or queries, not both." end self end |
#values ⇒ Array<Array(key, RDF::Value)> #values(vars, *data) ⇒ Query
Specify inline data for a query
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 |
# File 'lib/sparql/client/query.rb', line 583 def values(*args) return @values if args.empty? vars, *data = *args vars = Array(vars).map {|var| RDF::Query::Variable.new(var)} if vars.length == 1 # data may be a in array form or simple form if data.any? {|d| d.is_a?(Array)} && !data.all? {|d| d.is_a?(Array)} raise ArgumentError, "values data must all be in array form or all simple" end data = data.map {|d| Array(d)} end # Each data value must be an array with the same number of entries as vars unless data.all? {|d| d.is_a?(Array) && d.all? {|dd| dd.is_a?(RDF::Value) || dd.is_a?(String) || dd.nil?}} raise ArgumentError, "values data must each be an array of terms, strings, or nil" end # Turn strings into Literals data = data.map do |d| d.map do |nil_literal_or_term| case nil_literal_or_term when nil then nil when String then RDF::Literal(nil_literal_or_term) when RDF::Value then nil_literal_or_term else raise ArgumentError end end end [:values] = [vars, *data] self end |
#where(*patterns_queries) {|query| ... } ⇒ Query Also known as: whether
Block form can be used for chaining calls in addition to creating sub-select queries.
211 212 213 214 215 216 217 218 219 220 221 222 223 224 |
# File 'lib/sparql/client/query.rb', line 211 def where(*patterns_queries, &block) subqueries, patterns = patterns_queries.partition {|pq| pq.is_a? SPARQL::Client::Query} @patterns += build_patterns(patterns) @subqueries += subqueries if block_given? decorated_query = WhereDecorator.new(self) case block.arity when 1 then block.call(decorated_query) else decorated_query.instance_eval(&block) end end self end |