A |
| add [Rdf_mem.Triples] |
|
| add_storage [Rdf_graph] |
Add a storage to the list of registered storages.
|
| add_triple [Rdf_pg.Postgresql] |
|
| add_triple [Rdf_pg] |
|
| add_triple [Rdf_my.Mysql] |
|
| add_triple [Rdf_my] |
|
| add_triple [Rdf_mem.Mem] |
|
| add_triple [Rdf_mem] |
|
| add_triple [Rdf_graph.Storage] |
Adding a triple to the graph.
|
| add_triple [Rdf_graph.Graph] |
|
| add_triple_t [Rdf_pg.Postgresql] |
|
| add_triple_t [Rdf_my.Mysql] |
|
| add_triple_t [Rdf_mem.Mem] |
|
| add_triple_t [Rdf_graph.Storage] |
Adding a triple to the graph, curryfied form.
|
| add_triple_t [Rdf_graph.Graph] |
|
| apply_namespaces [Rdf_dot] |
|
B |
| blank_id_of_string [Rdf_node] |
Make a blank node id from a string.
|
| bool_of_literal [Rdf_node] |
Parse a literal to get a boolean.
|
| build_namespaces [Rdf_dot] |
|
C |
| compare [Rdf_uri] |
Comparison of two URIs, as usual.
|
| compare [Rdf_node.Ord_type] |
|
| concat [Rdf_uri] |
Add the given string to the path of the given URI, using '/' as separator.
|
| connect [Rdf_pg] |
|
| create_log_fun [Rdf_misc] |
Creating a log function.
|
| create_log_fun_with_set [Rdf_misc] |
Same as create_log_fun but also return a function to change
the log level.
|
| creation_queries [Rdf_pg] |
|
| creation_queries [Rdf_my] |
|
D |
| datetime_of_literal [Rdf_node] |
Parse a literal to get a datetime.
|
| db_of_options [Rdf_my] |
|
| dbg [Rdf_pg] |
|
| dbg [Rdf_my] |
|
| dbg [Rdf_mem] |
|
| dot_of_graph [Rdf_dot] |
|
E |
| empty [Rdf_mem.Triples] |
|
| equal [Rdf_uri] |
Equality over URIs.
|
| exec_prepared [Rdf_pg] |
|
| exec_prepared [Rdf_my] |
|
| exec_query [Rdf_pg] |
|
| exec_query [Rdf_my] |
|
| exists [Rdf_pg.Postgresql] |
|
| exists [Rdf_pg] |
|
| exists [Rdf_my.Mysql] |
|
| exists [Rdf_my] |
|
| exists [Rdf_mem.Mem] |
|
| exists [Rdf_mem] |
|
| exists [Rdf_graph.Storage] |
Same as Rdf_graph.Storage.find but only returns true if at least one triple
of the graph matches the constraints.
|
| exists [Rdf_graph.Graph] |
|
| exists_t [Rdf_pg.Postgresql] |
|
| exists_t [Rdf_my.Mysql] |
|
| exists_t [Rdf_mem.Mem] |
|
| exists_t [Rdf_graph.Storage] |
|
| exists_t [Rdf_graph.Graph] |
|
F |
| find [Rdf_pg.Postgresql] |
|
| find [Rdf_pg] |
|
| find [Rdf_my.Mysql] |
|
| find [Rdf_my] |
|
| find [Rdf_mem.Mem] |
|
| find [Rdf_mem.Triples] |
|
| find [Rdf_mem] |
|
| find [Rdf_graph.Storage] |
find ?sub ?pred ?obj g returns the list of triples matching the
constraints given by the optional subject, predicate and object.
|
| find [Rdf_graph.Graph] |
|
| find2_list [Rdf_mem.Triples] |
|
| find_list [Rdf_mem.Triples] |
|
| from_file [Rdf_xml] |
|
| from_string [Rdf_xml] |
|
G |
| get_option [Rdf_graph] |
get_options name options returns the value associated to the
option with the given name, in option list.
|
| get_tuple [Rdf_pg] |
|
| getisnull [Rdf_pg] |
|
| getvalue [Rdf_pg] |
|
| graph_name [Rdf_pg.Postgresql] |
|
| graph_name [Rdf_my.Mysql] |
|
| graph_name [Rdf_mem.Mem] |
|
| graph_name [Rdf_graph.Storage] |
Access to the graph name, as specified at its creation.
|
| graph_name [Rdf_graph.Graph] |
|
| graph_table_of_graph_name [Rdf_pg] |
|
| graph_table_of_graph_name [Rdf_my] |
|
| graph_table_of_id [Rdf_pg] |
|
| graph_table_of_id [Rdf_my] |
|
H |
| hash_of_node [Rdf_pg] |
|
| hash_of_node [Rdf_my] |
|
I |
| init_db [Rdf_pg] |
|
| init_db [Rdf_my] |
|
| init_graph [Rdf_pg] |
|
| init_graph [Rdf_my] |
|
| input_node [Rdf_xml] |
|
| input_prop [Rdf_xml] |
Fill a graph from a current state, a pair (global state, li counter),
and a property node.
|
M |
| make_select_node_list [Rdf_pg] |
|
| make_select_node_list [Rdf_my] |
|
| map_opt [Rdf_misc] |
|
| merge [Rdf_graph] |
merge g1 g2 add triples from g2 to g1.
|
| mk_literal [Rdf_node] |
Creation of a literal.
|
| mk_literal_bool [Rdf_node] |
Create a boolean literal with type uri from the given boolean.
|
| mk_literal_datetime [Rdf_node] |
Create a datetime literal with type uri from the given datetime d.
|
| mk_where_clause [Rdf_pg] |
|
| mk_where_clause [Rdf_my] |
|
N |
| name [Rdf_pg.Postgresql] |
|
| name [Rdf_my.Mysql] |
|
| name [Rdf_mem.Mem] |
|
| name [Rdf_graph.Storage] |
The name of the storage, for example "mysql".
|
| neturl [Rdf_uri] |
Get a Neturl.url from the given URI.
|
| new_blank_id [Rdf_pg.Postgresql] |
|
| new_blank_id [Rdf_pg] |
|
| new_blank_id [Rdf_my.Mysql] |
|
| new_blank_id [Rdf_my] |
|
| new_blank_id [Rdf_mem.Mem] |
|
| new_blank_id [Rdf_mem] |
|
| new_blank_id [Rdf_graph.Storage] |
Forging a new, unique blank node id.
|
| new_blank_id [Rdf_graph.Graph] |
|
| node_hash [Rdf_node] |
node_hash node returns an int64 identifiying (hopefully unically)) a given node.
|
| node_of_bool [Rdf_node] |
Create a literal node from the given boolean.
|
| node_of_datetime [Rdf_node] |
Create a literal node from the given datetime.
|
| node_of_hash [Rdf_pg] |
|
| node_of_hash [Rdf_my] |
|
| node_of_literal_string [Rdf_node] |
Shortcut for Literal (mk_literal ?typ ?lang string)
|
| node_of_uri_string [Rdf_node] |
Shortcut for Uri (Rdf_uri.uri string).
|
O |
| objects [Rdf_pg.Postgresql] |
|
| objects [Rdf_pg] |
|
| objects [Rdf_my.Mysql] |
|
| objects [Rdf_my] |
|
| objects [Rdf_mem.Mem] |
|
| objects [Rdf_mem] |
|
| objects [Rdf_graph.Storage] |
Return the list of nodes appearing in object position.
|
| objects [Rdf_graph.Graph] |
|
| objects_of [Rdf_pg.Postgresql] |
|
| objects_of [Rdf_pg] |
|
| objects_of [Rdf_my.Mysql] |
|
| objects_of [Rdf_my] |
|
| objects_of [Rdf_mem.Mem] |
|
| objects_of [Rdf_mem] |
|
| objects_of [Rdf_graph.Storage] |
objects_of g ~sub ~pred returns the list of nodes which are
objects in triples with the specified subject and predicate.
|
| objects_of [Rdf_graph.Graph] |
|
| of_neturl [Rdf_uri] |
|
| open_graph [Rdf_pg.Postgresql] |
|
| open_graph [Rdf_pg] |
|
| open_graph [Rdf_my.Mysql] |
|
| open_graph [Rdf_my] |
|
| open_graph [Rdf_mem.Mem] |
|
| open_graph [Rdf_mem] |
|
| open_graph [Rdf_graph.Storage] |
Creationg of the graph.
|
| open_graph [Rdf_graph.Graph] |
|
| open_graph [Rdf_graph] |
open_graph ~options uri_name creates a new graph.
|
| opt_of_string [Rdf_misc] |
|
| ordf_ns [Rdf_rdf] |
This is the uri used as predicate to store namespaces in a graph.
|
P |
| parent [Rdf_uri] |
Return a new URI with the path modified to parent path of the original URI.
|
| path [Rdf_uri] |
Get the path part of the URI.
|
| predicates [Rdf_pg.Postgresql] |
|
| predicates [Rdf_pg] |
|
| predicates [Rdf_my.Mysql] |
|
| predicates [Rdf_my] |
|
| predicates [Rdf_mem.Mem] |
|
| predicates [Rdf_mem] |
|
| predicates [Rdf_graph.Storage] |
Return the list of nodes appearing in predicate position.
|
| predicates [Rdf_graph.Graph] |
|
| predicates_of [Rdf_pg.Postgresql] |
|
| predicates_of [Rdf_pg] |
|
| predicates_of [Rdf_my.Mysql] |
|
| predicates_of [Rdf_my] |
|
| predicates_of [Rdf_mem.Mem] |
|
| predicates_of [Rdf_mem] |
|
| predicates_of [Rdf_graph.Storage] |
predicates_of g ~sub ~obj returns the list of nodes which are
predicates in triples with the specified subject and object.
|
| predicates_of [Rdf_graph.Graph] |
|
| prepare_queries [Rdf_pg] |
|
| prepare_queries [Rdf_my] |
|
| prepare_query [Rdf_pg] |
|
| prepare_query [Rdf_my] |
|
| prepared_count_triples [Rdf_pg] |
|
| prepared_count_triples [Rdf_my] |
|
| prepared_delete_triple [Rdf_pg] |
|
| prepared_delete_triple [Rdf_my] |
|
| prepared_insert_triple [Rdf_pg] |
|
| prepared_insert_triple [Rdf_my] |
|
| prepared_node_of_hash [Rdf_pg] |
|
| prepared_node_of_hash [Rdf_my] |
|
| prepared_object [Rdf_pg] |
|
| prepared_object [Rdf_my] |
|
| prepared_objects_of [Rdf_pg] |
|
| prepared_objects_of [Rdf_my] |
|
| prepared_predicate [Rdf_pg] |
|
| prepared_predicate [Rdf_my] |
|
| prepared_predicates_of [Rdf_pg] |
|
| prepared_predicates_of [Rdf_my] |
|
| prepared_subject [Rdf_pg] |
|
| prepared_subject [Rdf_my] |
|
| prepared_subjects_of [Rdf_pg] |
|
| prepared_subjects_of [Rdf_my] |
|
Q |
| query_node_list [Rdf_pg] |
|
| query_node_list [Rdf_my] |
|
| query_triple_list [Rdf_pg] |
|
| query_triple_list [Rdf_my] |
|
| quote_str [Rdf_pg] |
|
| quote_str [Rdf_my] |
|
R |
| rdf_ [Rdf_rdf] |
|
| rdf_Alt [Rdf_rdf] |
|
| rdf_Bag [Rdf_rdf] |
|
| rdf_Description [Rdf_rdf] |
|
| rdf_ID [Rdf_rdf] |
|
| rdf_List [Rdf_rdf] |
|
| rdf_Property [Rdf_rdf] |
|
| rdf_RDF [Rdf_rdf] |
|
| rdf_Seq [Rdf_rdf] |
|
| rdf_Statement [Rdf_rdf] |
|
| rdf_XMLLiteral [Rdf_rdf] |
|
| rdf_about [Rdf_rdf] |
|
| rdf_datatype [Rdf_rdf] |
|
| rdf_first [Rdf_rdf] |
|
| rdf_li [Rdf_rdf] |
|
| rdf_n [Rdf_rdf] |
|
| rdf_nil [Rdf_rdf] |
|
| rdf_nodeID [Rdf_rdf] |
|
| rdf_object [Rdf_rdf] |
|
| rdf_parseType [Rdf_rdf] |
|
| rdf_predicate [Rdf_rdf] |
|
| rdf_resource [Rdf_rdf] |
|
| rdf_rest [Rdf_rdf] |
|
| rdf_subject [Rdf_rdf] |
|
| rdf_type [Rdf_rdf] |
|
| rdf_value [Rdf_rdf] |
|
| rem [Rdf_mem.Triples] |
|
| rem_triple [Rdf_pg.Postgresql] |
|
| rem_triple [Rdf_pg] |
|
| rem_triple [Rdf_my.Mysql] |
|
| rem_triple [Rdf_my] |
|
| rem_triple [Rdf_mem.Mem] |
|
| rem_triple [Rdf_mem] |
|
| rem_triple [Rdf_graph.Storage] |
Removing a triple from the graph.
|
| rem_triple [Rdf_graph.Graph] |
|
| rem_triple_t [Rdf_pg.Postgresql] |
|
| rem_triple_t [Rdf_my.Mysql] |
|
| rem_triple_t [Rdf_mem.Mem] |
|
| rem_triple_t [Rdf_graph.Storage] |
Removing a triple from the graph, curryfied form.
|
| rem_triple_t [Rdf_graph.Graph] |
|
S |
| set_fragment [Rdf_uri] |
Modify the fragment part of the URI.
|
| string [Rdf_uri] |
Create a string from a URI.
|
| string_of_blank_id [Rdf_node] |
Get a string from a blank node id.
|
| string_of_error [Rdf_pg.Postgresql] |
|
| string_of_error [Rdf_pg] |
|
| string_of_error [Rdf_my.Mysql] |
|
| string_of_error [Rdf_my] |
|
| string_of_error [Rdf_mem.Mem] |
|
| string_of_error [Rdf_mem] |
|
| string_of_error [Rdf_graph.Storage] |
This function returns a message from the given error.
|
| string_of_node [Rdf_node] |
Create a string for the given node, using RDF turtle syntax conventions.
|
| string_of_opt [Rdf_misc] |
|
| subjects [Rdf_pg.Postgresql] |
|
| subjects [Rdf_pg] |
|
| subjects [Rdf_my.Mysql] |
|
| subjects [Rdf_my] |
|
| subjects [Rdf_mem.Mem] |
|
| subjects [Rdf_mem] |
|
| subjects [Rdf_graph.Storage] |
Return the list of nodes appearing in subject position.
|
| subjects [Rdf_graph.Graph] |
|
| subjects_of [Rdf_pg.Postgresql] |
|
| subjects_of [Rdf_pg] |
|
| subjects_of [Rdf_my.Mysql] |
|
| subjects_of [Rdf_my] |
|
| subjects_of [Rdf_mem.Mem] |
|
| subjects_of [Rdf_mem] |
|
| subjects_of [Rdf_graph.Storage] |
subjects_of g ~pred ~obj returns the list of nodes which are
subjects in triples with the specified predicate and object.
|
| subjects_of [Rdf_graph.Graph] |
|
T |
| table_exists [Rdf_pg] |
|
| table_exists [Rdf_my] |
|
| table_options [Rdf_pg] |
|
| table_options [Rdf_my] |
|
| to_file [Rdf_xml] |
|
| to_string [Rdf_xml] |
|
| transaction_commit [Rdf_pg.Postgresql] |
|
| transaction_commit [Rdf_pg] |
|
| transaction_commit [Rdf_my.Mysql] |
|
| transaction_commit [Rdf_my] |
|
| transaction_commit [Rdf_mem.Mem] |
|
| transaction_commit [Rdf_mem] |
|
| transaction_commit [Rdf_graph.Storage] |
Commit.
|
| transaction_commit [Rdf_graph.Graph] |
|
| transaction_rollback [Rdf_pg.Postgresql] |
|
| transaction_rollback [Rdf_pg] |
|
| transaction_rollback [Rdf_my.Mysql] |
|
| transaction_rollback [Rdf_my] |
|
| transaction_rollback [Rdf_mem.Mem] |
|
| transaction_rollback [Rdf_mem] |
|
| transaction_rollback [Rdf_graph.Storage] |
Rollback.
|
| transaction_rollback [Rdf_graph.Graph] |
|
| transaction_start [Rdf_pg.Postgresql] |
|
| transaction_start [Rdf_pg] |
|
| transaction_start [Rdf_my.Mysql] |
|
| transaction_start [Rdf_my] |
|
| transaction_start [Rdf_mem.Mem] |
|
| transaction_start [Rdf_mem] |
|
| transaction_start [Rdf_graph.Storage] |
Start a transaction.
|
| transaction_start [Rdf_graph.Graph] |
|
| triples [Rdf_mem.Triples] |
|
| triples_x [Rdf_mem.Triples] |
|
| triples_y [Rdf_mem.Triples] |
|
U |
| uri [Rdf_uri] |
Create a URI from a string.
|
| utf8_char_of_code [Rdf_utf8] |
conversions algorithm from http://en.wikipedia.org/wiki/UTF-8.
|
| utf8_char_of_index [Rdf_utf8] |
|
| utf8_index_of_char [Rdf_utf8] |
|
| utf8_nb_bytes_of_char [Rdf_utf8] |
|
| utf8_string_length [Rdf_utf8] |
|
V |
| version [Rdf_config] |
|
X |
| x_list [Rdf_mem.Triples] |
|