Class: SPARQL::Algebra::Operator::StrBefore

Inherits:
Binary show all
Includes:
Evaluatable
Defined in:
vendor/bundler/ruby/3.3.0/bundler/gems/sparql-796d3be4aa08/lib/sparql/algebra/operator/strbefore.rb

Overview

A SPARQL strbefore operator.

[121] BuiltInCall ::= ... | 'STRBEFORE' '(' Expression ',' Expression ')'

Examples:

SPARQL Grammar

PREFIX : <http://example.org/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
SELECT ?s (STRBEFORE(?str,"s") AS ?prefix) WHERE {
  ?s :str ?str
}

SSE

(prefix
 ((: <http://example.org/>)
  (xsd: <http://www.w3.org/2001/XMLSchema#>))
 (project (?s ?prefix)
  (extend ((?prefix (strbefore ?str "s")))
   (bgp (triple ?s :str ?str)))))

See Also:

Constant Summary collapse

NAME = 
:strbefore

Constants inherited from Binary

Binary::ARITY

Constants inherited from SPARQL::Algebra::Operator

ARITY, IsURI, URI

Constants included from Expression

Expression::PATTERN_PARENTS

Constants included from RDF::Util::Logger

RDF::Util::Logger::IOWrapper

Instance Attribute Summary

Attributes inherited from SPARQL::Algebra::Operator

#operands

Instance Method Summary collapse

Methods included from Evaluatable

#evaluate, #memoize, #replace_aggregate!, #replace_vars!

Methods inherited from Binary

#initialize

Methods inherited from SPARQL::Algebra::Operator

#aggregate?, arity, base_uri, #base_uri, base_uri=, #bind, #boolean, #constant?, #deep_dup, #each_descendant, #eql?, #evaluatable?, evaluate, #executable?, #first_ancestor, for, #formulae, #initialize, #inspect, #mergable?, #ndvars, #node?, #operand, #optimize, #optimize!, #parent, #parent=, #prefixes, prefixes, prefixes=, #rewrite, #to_binary, to_sparql, #to_sxp, #to_sxp_bin, #validate!, #variable?, #variables, #vars

Methods included from Expression

cast, #constant?, #evaluate, extension, extension?, extensions, for, #invalid?, new, #node?, open, #optimize, #optimize!, parse, register_extension, #to_sxp_bin, #valid?, #validate!, #variable?

Methods included from RDF::Util::Logger

#log_debug, #log_depth, #log_error, #log_fatal, #log_info, #log_recover, #log_recovering?, #log_statistics, #log_warn, #logger

Constructor Details

This class inherits a constructor from SPARQL::Algebra::Operator::Binary

Instance Method Details

#apply(left, right, **options) ⇒ RDF::Literal

The STRBEFORE function corresponds to the XPath fn:substring-before function. The arguments must be argument compatible otherwise an error is raised.

For compatible arguments, if the lexical part of the second argument occurs as a substring of the lexical part of the first argument, the function returns a literal of the same kind as the first argument arg1 (simple literal, plain literal same language tag, xsd:string). The lexical form of the result is the substring of the lexical form of arg1 that precedes the first occurrence of the lexical form of arg2. If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is the empty string.

If there is no such occurrence, an empty simple literal is returned.

Examples:

strbefore("abc","b") #=> "a"
strbefore("abc"@en,"bc") #=> "a"@en
strbefore("abc"@en,"b"@cy) #=> error
strbefore("abc"^^xsd:string,"") #=> ""^^xsd:string
strbefore("abc","xyz") #=> ""
strbefore("abc"@en, "z"@en) #=> ""
strbefore("abc"@en, "z") #=> ""
strbefore("abc"@en, ""@en) #=> ""@en
strbefore("abc"@en, "") #=> ""@en

Parameters:

Returns:

Raises:

  • (TypeError) —

    if operands are not compatible



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/sparql-796d3be4aa08/lib/sparql/algebra/operator/strbefore.rb', line 54

def apply(left, right, **options)
  case
  when !left.plain? || !right.plain?
    raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
  when !left.compatible?(right)
    raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
  when right.to_s.empty?
    # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
    RDF::Literal("", language: left.language, datatype: left.datatype)
  when !left.to_s.include?(right.to_s)
    # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
    RDF::Literal("")
  else
    parts = left.to_s.split(right.to_s)
    RDF::Literal(parts.first, language: left.language, datatype: left.datatype)
  end
end

#to_sparql(**options) ⇒ String

Returns a partial SPARQL grammar for this operator.

Returns:



77
78
79
 
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/sparql-796d3be4aa08/lib/sparql/algebra/operator/strbefore.rb', line 77

def to_sparql(**options)
  "STRBEFORE(" + operands.to_sparql(delimiter: ', ', **options) + ")"
end