@spec add(t(), input(), keyword()) :: t()

Adds triples and quads to a RDF.Dataset.

The triples can be provided in any form accepted by add/2.

• as a single statement tuple
• an RDF.Description
• an RDF.Graph
• an RDF.Dataset
• or a list with any combination of the former

The graph option allows to set a different destination graph to which the statements should be added, ignoring the graph context of given quads or the name of given graphs in input.

Note: When the statements to be added are given as another RDF.Dataset and a destination graph is set with the graph option, the descriptions of the subjects in the different graphs are aggregated.

@spec canonical_hash(
  t() | RDF.Graph.t(),
  keyword()
) :: binary()

Returns a hash of the canonical form of the given dataset.

This hash is computed as follows:

1. Compute the canonical form of the dataset according to the RDF Dataset Canonicalization spec using canonicalize/1.
2. Serialize this canonical dataset to N-Quads sorted by Unicode code point order.
3. Compute the SHA-256 of this N-Quads serialization.

Note that the data structure is not relevant for the canonical hash, i.e. the same hash is generated for the same data regardless of whether it is passed in an RDF.Graph, RDF.Dataset or RDF.Description.

Options

• :hash_algorithm (default: :sha256): Allows to set the hash algorithm to be used in step 3. Any of the :crypto.hash_algorithm() values of Erlang's :crypto module are allowed. Note that this does NOT affect the hash function used during the

Example

iex> RDF.Dataset.new([{~B<foo>, EX.p(), ~B<bar>}, {~B<bar>, EX.p(), ~B<foo>}])
...> |> RDF.Dataset.canonical_hash()
"053688e09a20a49acc3e1a5e6403c827b817eef9e4c90bfd71f2360e2a6446aa"

iex> RDF.Graph.new([{~B<other>, EX.p(), ~B<bar>}, {~B<bar>, EX.p(), ~B<other>}])
...> |> RDF.Graph.canonical_hash()
"053688e09a20a49acc3e1a5e6403c827b817eef9e4c90bfd71f2360e2a6446aa"

@spec canonicalize(
  t() | RDF.Graph.t(),
  keyword()
) :: t()

Canonicalizes the blank nodes of a dataset according to the RDF Dataset Canonicalization spec.

See the RDF.Canonicalization module documentation on available options.

Example

iex> RDF.Dataset.new([{~B<foo>, EX.p(), ~B<bar>}, {~B<bar>, EX.p(), ~B<foo>}])
...> |> RDF.Dataset.canonicalize()
RDF.Dataset.new([{~B<c14n0>, EX.p(), ~B<c14n1>}, {~B<c14n1>, EX.p(), ~B<c14n0>}])

@spec change_name(t(), RDF.Statement.coercible_graph_name()) :: t()

Changes the dataset name of dataset.

@spec default_graph(t()) :: RDF.Graph.t()

The default graph of a RDF.Dataset.

@spec delete(t(), input(), keyword()) :: t()

Deletes statements from a RDF.Dataset.

The graph option allows to set a different destination graph from which the statements should be deleted, ignoring the graph context of given quads or the name of given graphs.

Note: When the statements to be deleted are given as another RDF.Dataset, the dataset name must not match dataset name of the dataset from which the statements are deleted. If you want to delete only datasets with matching names, you can use RDF.Data.delete/2.

@spec delete_default_graph(t()) :: t()

Deletes the default graph.

@spec delete_graph(
  t(),
  RDF.Statement.graph_name() | [RDF.Statement.graph_name()] | nil
) :: t()

Deletes the given graph.

@spec describes?(t(), RDF.Statement.t(), RDF.Statement.coercible_graph_name() | nil) ::
  boolean()

Checks if a graph of a RDF.Dataset contains statements about the given resource.

Examples

  iex> RDF.Dataset.new([{EX.S1, EX.p1, EX.O1}]) |> RDF.Dataset.describes?(EX.S1)
  true
  iex> RDF.Dataset.new([{EX.S1, EX.p1, EX.O1}]) |> RDF.Dataset.describes?(EX.S2)
  false

@spec empty?(t()) :: boolean()

Returns if the given dataset is empty.

Note: You should always prefer this over the use of Enum.empty?/1 as it is significantly faster.

@spec equal?(t() | any(), t() | any()) :: boolean()

Checks if two RDF.Datasets are equal.

Two RDF.Datasets are considered to be equal if they contain the same triples and have the same name.

@spec fetch(t(), RDF.Statement.graph_name() | nil) :: {:ok, RDF.Graph.t()} | :error

Fetches the RDF.Graph with the given name.

When a graph with the given name can not be found can not be found :error is returned.

Examples

iex> dataset = RDF.Dataset.new([{EX.S1, EX.P1, EX.O1, EX.Graph}, {EX.S2, EX.P2, EX.O2}])
...> RDF.Dataset.fetch(dataset, EX.Graph)
{:ok, RDF.Graph.new({EX.S1, EX.P1, EX.O1}, name: EX.Graph)}
iex> RDF.Dataset.fetch(dataset, nil)
{:ok, RDF.Graph.new({EX.S2, EX.P2, EX.O2})}
iex> RDF.Dataset.fetch(dataset, EX.Foo)
:error

@spec get(t(), RDF.Statement.graph_name() | nil, RDF.Graph.t() | nil) ::
  RDF.Graph.t() | nil

Fetches the RDF.Graph with the given name.

When a graph with the given name can not be found can not be found the optionally given default value or nil is returned

Examples

iex> dataset = RDF.Dataset.new([{EX.S1, EX.P1, EX.O1, EX.Graph}, {EX.S2, EX.P2, EX.O2}])
...> RDF.Dataset.get(dataset, EX.Graph)
RDF.Graph.new({EX.S1, EX.P1, EX.O1}, name: EX.Graph)
iex> RDF.Dataset.get(dataset, nil)
RDF.Graph.new({EX.S2, EX.P2, EX.O2})
iex> RDF.Dataset.get(dataset, EX.Foo)
nil
iex> RDF.Dataset.get(dataset, EX.Foo, :bar)
:bar

@spec get_and_update(
  t(),
  RDF.Statement.graph_name() | nil,
  get_and_update_graph_fun()
) ::
  {RDF.Graph.t(), t()}

Gets and updates the graph with the given name, in a single pass.

Invokes the passed function on the RDF.Graph with the given name; this function should return either {graph_to_return, new_graph} or :pop.

If the passed function returns {graph_to_return, new_graph}, the return value of get_and_update is {graph_to_return, new_dataset} where new_dataset is the input Dataset updated with new_graph for the given name.

If the passed function returns :pop the graph with the given name is removed and a {removed_graph, new_dataset} tuple gets returned.

Examples

iex> dataset = RDF.Dataset.new({EX.S, EX.P, EX.O, EX.Graph})
...> RDF.Dataset.get_and_update(dataset, EX.Graph, fn current_graph ->
...>     {current_graph, {EX.S, EX.P, EX.NEW}}
...>   end)
{RDF.Graph.new({EX.S, EX.P, EX.O}, name: EX.Graph), RDF.Dataset.new({EX.S, EX.P, EX.NEW, EX.Graph})}

@spec graph(t(), RDF.Statement.graph_name() | nil) :: RDF.Graph.t()

The graph with given name.

@spec graph_count(t()) :: non_neg_integer()

The number of graphs within a RDF.Dataset.

Examples

iex> RDF.Dataset.new([
...>   {EX.S1, EX.p1, EX.O1},
...>   {EX.S2, EX.p2, EX.O2},
...>   {EX.S1, EX.p2, EX.O3, EX.Graph}])
...> |> RDF.Dataset.graph_count()
2

@spec graphs(t()) :: [RDF.Graph.t()]

The set of all graphs.

@spec include?(t(), input(), keyword()) :: boolean()

Checks if the given input statements exist within dataset.

The graph option allows to set a different destination graph in which the statements should be checked, ignoring the graph context of given quads or the name of given graphs.

Examples

  iex> dataset = RDF.Dataset.new([
  ...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
  ...>   {EX.S2, EX.p2, EX.O2},
  ...>   {EX.S1, EX.p2, EX.O3}])
  ...> RDF.Dataset.include?(dataset, {EX.S1, EX.p1, EX.O1, EX.Graph})
  true

@spec intersection(t(), t() | RDF.Graph.t() | RDF.Description.t() | input()) :: t()

Returns a new dataset that is the intersection of the given dataset with the given data.

The data can be given in any form an RDF.Dataset can be created from.

Examples

iex> RDF.Dataset.new([
...>   {EX.S1, EX.p(), [EX.O1, EX.O2]},
...>   {EX.S2, EX.p(), EX.O3, EX.Graph}
...> ])
...> |> RDF.Dataset.intersection([
...>     {EX.S1, EX.p(), EX.O2},
...>     {EX.S2, EX.p(), EX.O3}
...>   ])
RDF.Dataset.new({EX.S1, EX.p(), EX.O2})

See RDF.Canonicalization.isomorphic?/2.

@spec map(t(), RDF.Statement.term_mapping()) :: map()

Returns a nested map of a RDF.Dataset where each element from its quads is mapped with the given function.

The function fun will receive a tuple {statement_position, rdf_term} where statement_position is one of the atoms :subject, :predicate, :object or :graph_name while rdf_term is the RDF term to be mapped. When the given function returns nil this will be interpreted as an error and will become the overhaul result of the map/2 call.

Examples

iex> [
...>   {~I<http://example.com/S>, ~I<http://example.com/p>, ~L"Foo", ~I<http://example.com/Graph>},
...>   {~I<http://example.com/S>, ~I<http://example.com/p>, RDF.XSD.integer(42), }
...> ]
...> |> RDF.Dataset.new()
...> |> RDF.Dataset.map(fn
...>      {:graph_name, graph_name} ->
...>        graph_name
...>      {:predicate, predicate} ->
...>        predicate
...>        |> to_string()
...>        |> String.split("/")
...>        |> List.last()
...>        |> String.to_atom()
...>    {_, term} ->
...>      RDF.Term.value(term)
...>    end)
%{
  ~I<http://example.com/Graph> => %{
    "http://example.com/S" => %{p: ["Foo"]}
  },
  nil => %{
    "http://example.com/S" => %{p: [42]}
  }
}

@spec name(t()) :: RDF.Statement.graph_name()

Returns the dataset name IRI of dataset.

@spec new() :: t()

Creates an empty unnamed RDF.Dataset.

@spec new(input() | keyword()) :: t()

Creates an RDF.Dataset.

If a keyword list is given an empty dataset is created. Otherwise, an unnamed dataset initialized with the given data is created.

See new/2 for available arguments and the different ways to provide data.

Examples

RDF.Dataset.new(name: EX.GraphName)

RDF.Dataset.new(init: {EX.S, EX.p, EX.O})

RDF.Dataset.new({EX.S, EX.p, EX.O})

@spec new(
  input(),
  keyword()
) :: t()

Creates an RDF.Dataset initialized with data.

The initial RDF triples can be provided in any form accepted by add/3.

Available options:

• name: the name of the dataset to be created
• init: some data with which the dataset should be initialized; the data can be provided in any form accepted by add/3 and above that also with a function returning the initialization data in any of these forms

The set of all resources used in the objects within a RDF.Dataset.

Note: This function does collect only IRIs and BlankNodes, not Literals.

Examples

iex> RDF.Dataset.new([
...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
...>   {EX.S2, EX.p2, EX.O2, EX.Graph},
...>   {EX.S3, EX.p1, EX.O2},
...>   {EX.S4, EX.p2, RDF.bnode(:bnode)},
...>   {EX.S5, EX.p3, "foo"}
...> ]) |> RDF.Dataset.objects()
MapSet.new([RDF.iri(EX.O1), RDF.iri(EX.O2), RDF.bnode(:bnode)])

@spec pop(t()) :: {RDF.Statement.t() | nil, t()}

Pops an arbitrary statement from a RDF.Dataset.

@spec pop(t(), RDF.Statement.coercible_graph_name()) :: {RDF.Graph.t() | nil, t()}

Pops the graph with the given name.

Removes the graph of the given graph_name from dataset.

Returns a tuple containing the graph of the given name and the updated dataset without this graph. nil is returned instead of the graph if dataset does not contain a graph_name of the given graph_name.

Examples

iex> dataset = RDF.Dataset.new([
...>   {EX.S1, EX.P1, EX.O1, EX.Graph},
...>   {EX.S2, EX.P2, EX.O2}])
...> RDF.Dataset.pop(dataset, EX.Graph)
{
  RDF.Graph.new({EX.S1, EX.P1, EX.O1}, name: EX.Graph),
  RDF.Dataset.new({EX.S2, EX.P2, EX.O2})
}
iex> RDF.Dataset.pop(dataset, EX.Foo)
{nil, dataset}

The set of all properties used in the predicates within all graphs of a RDF.Dataset.

Examples

iex> RDF.Dataset.new([
...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
...>   {EX.S2, EX.p2, EX.O2},
...>   {EX.S1, EX.p2, EX.O3}]) |>
...>   RDF.Dataset.predicates()
MapSet.new([EX.p1, EX.p2])

@spec prefixes(t()) :: RDF.PrefixMap.t() | nil

Returns the aggregated prefixes of all graphs of dataset as a RDF.PrefixMap.

@spec put(t(), input(), keyword()) :: t()

Adds statements to a RDF.Dataset overwriting existing statements with the subjects given in the input data.

By overwriting statements with the same subject, this function has a similar semantics as RDF.Graph.put/3, if you want to replace whole graphs use put_graph/3 instead.

The graph option allows to set a different destination graph to which the statements should be added, ignoring the graph context of given quads or the name of given graphs in input.

Note: When the statements to be added are given as another RDF.Dataset and a destination graph is set with the graph option, the descriptions of the subjects in the different graphs are aggregated.

Examples

iex> dataset = RDF.Dataset.new({EX.S, EX.P1, EX.O1})
...> RDF.Dataset.put(dataset, {EX.S, EX.P2, EX.O2})
RDF.Dataset.new({EX.S, EX.P2, EX.O2})
iex> RDF.Dataset.put(dataset, {EX.S2, EX.P2, EX.O2})
RDF.Dataset.new([{EX.S, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}])

@spec put_graph(t(), input(), keyword()) :: t()

Adds new graphs to a RDF.Dataset overwriting any existing graphs with the same name.

The graph option allows to set a different destination graph to which the statements should be added, ignoring the graph context of given quads or the name of given graphs in input.

Note: When the statements to be added are given as another RDF.Dataset and a destination graph is set with the graph option, the descriptions of the subjects in the different graphs are aggregated.

@spec put_properties(t(), input(), keyword()) :: t()

Adds statements to a RDF.Dataset and overwrites all existing statements with the same subject-predicate combinations given in the input data.

The graph option allows to set a different destination graph to which the statements should be added, ignoring the graph context of given quads or the name of given graphs in input.

Note: When the statements to be added are given as another RDF.Dataset and a destination graph is set with the graph option, the descriptions of the subjects in the different graphs are aggregated.

Examples

iex> dataset = RDF.Dataset.new({EX.S, EX.P1, EX.O1})
...> RDF.Dataset.put_properties(dataset, {EX.S, EX.P1, EX.O2})
RDF.Dataset.new({EX.S, EX.P1, EX.O2})
iex> RDF.Dataset.put_properties(dataset, {EX.S, EX.P2, EX.O2})
RDF.Dataset.new([{EX.S, EX.P1, EX.O1}, {EX.S, EX.P2, EX.O2}])
iex> RDF.Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}])
...> |> RDF.Dataset.put_properties([{EX.S1, EX.P2, EX.O3}, {EX.S2, EX.P2, EX.O3}])
RDF.Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, EX.O3}, {EX.S2, EX.P2, EX.O3}])

@spec quads(
  t(),
  keyword()
) :: [RDF.Quad.t()]

All statements within all graphs of a RDF.Dataset as quads.

When the optional :filter_star flag is set to true RDF-star statements with a triple as subject or object will be filtered. The default value is false.

Examples

  iex> RDF.Dataset.new([
  ...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
  ...>   {EX.S2, EX.p2, EX.O2},
  ...>   {EX.S1, EX.p2, EX.O3}])
  ...> |> RDF.Dataset.quads()
  [{RDF.iri(EX.S1), RDF.iri(EX.p2), RDF.iri(EX.O3), nil},
   {RDF.iri(EX.S2), RDF.iri(EX.p2), RDF.iri(EX.O2), nil},
   {RDF.iri(EX.S1), RDF.iri(EX.p1), RDF.iri(EX.O1), RDF.iri(EX.Graph)}]

The set of all resources used within a RDF.Dataset.

Examples

iex> RDF.Dataset.new([ ...> {EX.S1, EX.p1, EX.O1, EX.Graph}, ...> {EX.S2, EX.p1, EX.O2, EX.Graph}, ...> {EX.S2, EX.p2, RDF.bnode(:bnode)}, ...> {EX.S3, EX.p1, "foo"} ...> ]) |> RDF.Dataset.resources() MapSet.new([RDF.iri(EX.S1), RDF.iri(EX.S2), RDF.iri(EX.S3),

RDF.iri(EX.O1), RDF.iri(EX.O2), RDF.bnode(:bnode), EX.p1, EX.p2])

@spec statement_count(t()) :: non_neg_integer()

The number of statements within a RDF.Dataset.

Examples

iex> RDF.Dataset.new([
...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
...>   {EX.S2, EX.p2, EX.O2},
...>   {EX.S1, EX.p2, EX.O3}]) |>
...>   RDF.Dataset.statement_count()
3

@spec statements(
  t(),
  keyword()
) :: [RDF.Statement.t()]

All statements within all graphs of a RDF.Dataset.

While the statements of named graphs are returned as quad tuples, the statements of the default graph are returned as triples. If you want to get quads or triples uniformly, use the quads/2 resp. triples/2 functions instead.

When the optional :filter_star flag is set to true RDF-star statements with a triple as subject or object will be filtered. The default value is false.

Examples

  iex> RDF.Dataset.new([
  ...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
  ...>   {EX.S2, EX.p2, EX.O2},
  ...>   {EX.S1, EX.p2, EX.O3}])
  ...> |> RDF.Dataset.statements()
  [{RDF.iri(EX.S1), RDF.iri(EX.p2), RDF.iri(EX.O3)},
   {RDF.iri(EX.S2), RDF.iri(EX.p2), RDF.iri(EX.O2)},
   {RDF.iri(EX.S1), RDF.iri(EX.p1), RDF.iri(EX.O1), RDF.iri(EX.Graph)}]

The set of all subjects used in the statement within all graphs of a RDF.Dataset.

Examples

iex> RDF.Dataset.new([
...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
...>   {EX.S2, EX.p2, EX.O2},
...>   {EX.S1, EX.p2, EX.O3}]) |>
...>   RDF.Dataset.subjects()
MapSet.new([RDF.iri(EX.S1), RDF.iri(EX.S2)])

@spec triples(
  t(),
  keyword()
) :: [RDF.Triple.t()]

All statements within all graphs of a RDF.Dataset as triples.

When the optional :filter_star flag is set to true RDF-star statements with a triple as subject or object will be filtered. The default value is false.

Note: When a triple is present in multiple graphs it will be present in the resulting list of triples multiple times for performance reasons. If you want to get a list with unique triples, you'll have to apply Enum.uniq/1 on the result.

Examples

  iex> RDF.Dataset.new([
  ...>   {EX.S1, EX.p1, EX.O1, EX.Graph},
  ...>   {EX.S2, EX.p2, EX.O2},
  ...>   {EX.S1, EX.p2, EX.O3}])
  ...> |> RDF.Dataset.triples()
  [{RDF.iri(EX.S1), RDF.iri(EX.p2), RDF.iri(EX.O3)},
   {RDF.iri(EX.S2), RDF.iri(EX.p2), RDF.iri(EX.O2)},
   {RDF.iri(EX.S1), RDF.iri(EX.p1), RDF.iri(EX.O1)}]

@spec update(
  t(),
  RDF.Statement.graph_name(),
  RDF.Graph.input() | nil,
  update_graph_fun()
) :: t()

Updates a graph in dataset with the given function.

If graph_name is present in dataset, fun is invoked with argument graph and its result is used as the new graph with the given graph_name. If graph_name is not present in dataset, initial is inserted with the given graph_name. If no initial value is given, the dataset remains unchanged. If nil is returned by fun, the respective graph will be removed from dataset.

The initial value and the returned values by the update function will be coerced to proper RDF graphs before added. If the initial or returned graph is a RDF.Graph with another graph name, it will still be added using the given graph_name.

Examples

iex> RDF.Dataset.new({EX.S, EX.p, EX.O, EX.Graph})
...> |> RDF.Dataset.update(EX.Graph,
...>      fn graph -> RDF.Graph.add(graph, {EX.S, EX.p, EX.O2})
...>    end)
RDF.Dataset.new([{EX.S, EX.p, EX.O, EX.Graph}, {EX.S, EX.p, EX.O2, EX.Graph}])

iex> RDF.Dataset.new()
...> |> RDF.Dataset.update(EX.Graph, RDF.Graph.new({EX.S, EX.p, EX.O}),
...>      fn graph -> RDF.Graph.add(graph, {EX.S, EX.p, EX.O2})
...>    end)
RDF.Dataset.new([{EX.S, EX.p, EX.O, EX.Graph}])

@spec values(
  t(),
  keyword()
) :: map()

Returns a nested map of the native Elixir values of a RDF.Dataset.

When a :context option is given with a RDF.PropertyMap, predicates will be mapped to the terms defined in the RDF.PropertyMap, if present.

Examples

iex> [
...>   {~I<http://example.com/S>, ~I<http://example.com/p>, ~L"Foo", ~I<http://example.com/Graph>},
...>   {~I<http://example.com/S>, ~I<http://example.com/p>, RDF.XSD.integer(42), }
...> ]
...> |> RDF.Dataset.new()
...> |> RDF.Dataset.values()
%{
  "http://example.com/Graph" => %{
    "http://example.com/S" => %{"http://example.com/p" => ["Foo"]}
  },
  nil => %{
    "http://example.com/S" => %{"http://example.com/p" => [42]}
  }
}

@spec who_describes(t(), RDF.Statement.coercible_subject()) :: [RDF.Graph.t()]

Returns the names of all graphs of a RDF.Dataset containing statements about the given subject.

Examples

  iex> dataset = RDF.Dataset.new([
  ...>   {EX.S1, EX.p, EX.O},
  ...>   {EX.S2, EX.p, EX.O},
  ...>   {EX.S1, EX.p, EX.O, EX.Graph1},
  ...>   {EX.S2, EX.p, EX.O, EX.Graph2}])
  ...> RDF.Dataset.who_describes(dataset, EX.S1)
  [nil, RDF.iri(EX.Graph1)]