Elementary query for triples. Subject and Predicate are atoms
representing the fully qualified URL of the resource. Object is
either an atom representing a resource or literal(Value) if the
object is a literal value. If a value of the form
NameSpaceID:LocalName is provided it is expanded to a ground
atom using expand_goal/2. This implies you can use this
construct in compiled code without paying a performance penalty.
Literal values take one of the following forms:
- Atom
- If the value is a simple atom it is the textual representation
of a string literal without explicit type or language
qualifier.
- lang(LangID, Atom)
- Atom represents the text of a string literal qualified with
the given language.
- type(TypeID, Value)
- Used for attributes qualified using the
rdf:datatype
TypeID. The Value is either the textual representation or a
natural Prolog representation. See the option
convert_typed_literal(:Convertor) of the parser. The storage
layer provides efficient handling of atoms, integers (64-bit)
and floats (native C-doubles). All other data is represented
as a Prolog record.
For literal querying purposes, Object can be of the form
literal(+Query, -Value), where Query is one of the terms below.
If the Query takes a literal argument and the value has a
numeric type numerical comparison is performed.
- plain(+Text)
- Perform exact match and demand the language or type qualifiers
to match. This query is fully indexed.
- icase(+Text)
- Perform a full but case-insensitive match. This query is
fully indexed.
- exact(+Text)
- Same as
icase(Text). Backward compatibility.
- substring(+Text)
- Match any literal that contains Text as a case-insensitive
substring. The query is not indexed on Object.
- word(+Text)
- Match any literal that contains Text delimited by a non
alpha-numeric character, the start or end of the string. The
query is not indexed on Object.
- prefix(+Text)
- Match any literal that starts with Text. This call is intended
for completion. The query is indexed using the skip list of
literals.
- ge(+Literal)
- Match any literal that is equal or larger than Literal in the
ordered set of literals.
- gt(+Literal)
- Match any literal that is larger than Literal in the ordered set
of literals.
- eq(+Literal)
- Match any literal that is equal to Literal in the ordered set
of literals.
- le(+Literal)
- Match any literal that is equal or smaller than Literal in the
ordered set of literals.
- lt(+Literal)
- Match any literal that is smaller than Literal in the ordered set
of literals.
- between(+Literal1, +Literal2)
- Match any literal that is between Literal1 and Literal2 in the
ordered set of literals. This may include both Literal1 and
Literal2.
- like(+Pattern)
- Match any literal that matches Pattern case insensitively,
where the `*' character in Pattern matches zero or more
characters.
Backtracking never returns duplicate triples. Duplicates can be
retrieved using rdf/4. The predicate rdf/3 raises a type-error
if called with improper arguments. If rdf/3 is called with a
term literal(_) as Subject or Predicate object it fails
silently. This allows for graph matching goals like
rdf(S,P,O),rdf(O,P2,O2) to proceed without errors.