# Using RDF data Using RDF data Neptune Analytics supports importing RDF data using the n-triples format. The handling of RDF values is described below, including how RDF data is interpreted as LPG concepts and can be queried using openCypher. ## Handling of RDF values The handling of RDF specific values, that don‘t have a direct equivalent in LPG, is described here. ### IRIs Values of type IRI, like `` , are stored as such. IRIs and Strings are distinct data types. Calling openCypher function `TOSTRING()` on an IRI returns a string containing the IRI wrapped inside `<>`. For example, if `x` is the IRI ``, then `TOSTRING(x)` returns `""`. When serializing openCypher query results in json format, IRI values are included as strings in this same format. ### Language-tagged literals Values like `"Hallo"@de` are treated as follows: + When used as input for openCypher string functions, like `trim()`, a language-tagged string is treated as a simple string; so `trim("Hallo"@de)` is equivalent to `trim("Hallo")`. + When used in comparison operations, like `x = y` or `x <> y` or `x < y` or `ORDER BY`, a language-tagged literal is “greater than” (and thus “not equal to”) the corresponding simple string: `"Hallo" < "Hallo"@de`. Calling a function, such as `TOSTRING()` on a language-tagged literal, returns that literal as a string without language tag. For example, if `x` is the value `"Hallo"@de`, then `TOSTRING(x)` returns `"Hallo"`. When serializing openCypher query results in JSON format, language-tagged literals are also serialized as strings without an associated language tag. ### Blank nodes Blank nodes in n-triples data files are replaced with globally unique IRIs at import time. Loading RDF datasets that contains blank nodes is supported; but those blank nodes are represented as IRIs in the graph. When loading ntriples files the parameter `blankNodeHandling` needs to be specified, with the value `convertToIri`. The generated IRI for a blank node has the format: `` In these IRIs, `scope` is a unique identifier for the blank node scope, and `id` is the blank node identifier in the file. For example for a blank node `_:b123` the generated IRI could be ``. The **blank node scope** (e.g. 737c0b5386448f78) is generated by Neptune Analytics and designates one file within one load operation. This means that when two different ntriples files reference the same blank node identifier, like `_:b123`, there will be two IRIs generated, namely one for each file. All references to `_:b123` within the first file will end up as references to the first IRI, like ``, and all references within the second file will end up referring to another IRI, like ``. # Referencing IRIs in queries There are two ways to reference an IRI in an openCypher query: + Wrap the full IRI inside `<` and `>` . Depending on where in the query this IRI is referenced, the IRI is then provided as a String, such as `""` (when the IRI is the value of property `~id`), or in backticks such as ```` (when the IRI is a label, or property key). ``` CREATE (:`` {`~id`: ""}) ``` + Define a PREFIX at the start of the query, and inside the query reference an IRI using `prefix::suffix`. For example, after `PREFIX ex: ` the reference `ex::Alice` also references the full IRI ``. ``` PREFIX foaf: PREFIX ex: CREATE (: foaf::Person {`~id`: ex::Alice}) ``` Additional query examples below show the use of both full IRIs and the prefix syntax. # Mapping RDF triples to LPG concepts There are three rules that define how RDF triples correspond to LPG concepts: ``` Case RDF triple ⇆ LPG concept ----------------------------------------------------------------- Case #1 { rdf:type } ⇆ vertex with id + label Case #2 { "literal"} ⇆ vertex property Case #3 { } ⇆ edge with label ``` **Case \$11: Vertex with id and label** A triple like: ``` rdf:type ``` is equivalent to creating the vertex in openCypher like: ``` CREATE (:`` {`~id`: ""}) ``` In this example, the vertex label `` is interpreted and stored as an IRI. **Note** The back quote syntax ```` is part of openCypher which allows inserting characters that normally cannot be used in labels. Using this mechanism, it’s possible to include complete IRIs in a query. Using `PREFIX`, the same `CREATE` query could look like: ``` PREFIX foaf: PREFIX ex: CREATE (: foaf::Person {`~id`: ex::Alice}) ``` To match the newly created vertex based on its id: ``` MATCH (v {`~id`: ""}) RETURN v ``` or equivalently: ``` PREFIX ex: MATCH (v {`~id`: ex::Alice}) RETURN v ``` To find vertices with that RDF Class/LPG Label: ``` MATCH (v:``) RETURN v ``` or equivalently: ``` PREFIX foaf: MATCH (v : foaf::Person) RETURN v ``` **Case \$12: Vertex property** A triple like: ``` "Alice Smith" ``` is equivalent to defining with openCypher node with a given `~id` and property, where both the `~id` and the property key are IRIs: ``` CREATE ({`~id`: "", ``: "Alice Smith" }) ``` or equivalently: ``` PREFIX foaf: PREFIX ex: CREATE ({`~id`: ex::Alice, foaf::name: "Alice Smith" }) ``` To match the vertex with that property: ``` MATCH (v {``: "Alice Smith"}) RETURN v ``` or equivalently: ``` PREFIX foaf: MATCH (v { foaf::name : "Alice Smith"}) RETURN v ``` **Case \$13: Edge** A triple like: ``` ``` is equivalent to defining with OpenCypher an edge like this, where the edge label and vertices ids are all IRIs: ``` CREATE ({`~id`: ""}) -[:``]->({`~id`: ""}) ``` or equivalently: ``` PREFIX ex: CREATE ({`~id`: ex::Alice })-[: ex::knows ]->({`~id`: ex::Bob }) ``` To match the edges with that label: ``` MATCH (v)-[:``]->(w) RETURN v, w ``` or equivalently: ``` PREFIX ex: MATCH (v)-[: ex::knows ]->(w) RETURN v, w ``` ## Query Examples **Matching language-tagged literals** If this triple was loaded from a dataset: ``` "Hallo"@de ``` then it will **not** be matched by this query: ``` MATCH (n) WHERE n.`` = "Hallo" ``` because the language-tagged literal `"Hallo"@de` and the string “Hallo” are not equal. For more information, see [Language-tagged literals](using-rdf-data.md#rdf-handling-language-tagged-literals). The query can use `TOSTRING()` in order to find the match: ``` MATCH (n) WHERE TOSTRING(n.``) = "Hallo" ```