Assuming a SPARQL query should filter on the length of labels:
SELECT ?label FROM <http://mygraph.com> WHERE { ?s ?p ?label FILTER(regex(str(?label), "^.{1,256}$") ) }
ISQL uses '$' character as a prefix for macro names of its preprocessor. When '$' character is used in SPARQL query to be executed in ISQL, the character should be replaced with '$$' notation or an escape char + numeric code:
SQL> SPARQL SELECT ?label FROM <http://mygraph.com> WHERE { ?s ?p ?label FILTER(REGEX(str(?label), "^.{1,256}$$") ) }
Note also that the FILTER written in this way, finds ?label-s with length less than 256.
To achieve fast results, REGEX should be replaced with the bif:length function:
SQL> SPARQL SELECT ?label FROM <http://mygraph.com> WHERE { ?s ?p ?label FILTER (bif:length(str(?label))<= 256) }
In this way the SPARQL query execution can work much faster if the interoperability is not required and ?label-s are numerous.
One possible way to find on which table deadlocks occur is to execute the following statement:
SELECT TOP 10 * FROM SYS_L_STAT ORDER BY deadlocks DESC
In order to avoid out of memory error, you should make sure the values for the paramaters NumberOfBuffers and MaxCheckpointRemap are not set with the same values.
For example, the following configuration will cause an error out of memory:
# virtuoso.ini ... [Parameters] NumberOfBuffers = 246837 MaxDirtyBuffers = 18517 MaxCheckpointRemap = 246837 ...
Changing the value of the parameter MaxCheckpointRemap with let's say 1/4 of the DB size will resolve the issue.
These Linked Data Views options basically persist the triples in the transient View Graph in the Native Quad Store. The Data Sync is how you keep the transient views in sync with the persisted triples.
Without this capability you cannot exploit faceted browsing without severe performance overhead when using Linked Data based conceptual views over ODBC or JDBC accessible data sources.
Note: Using these options when the RFViews have already been created is not currently possible via the Conductor UI. Instead you should be able to add them manually from isql:
The following examples demonstrate how to manage date range in a SPARQL query:
Example with date range
SELECT ?s ?date FROM <http://dbpedia.org> WHERE { ?s ?p ?date . FILTER ( ?date >= "19450101"^^xsd:date && ?date <= "19451231"^^xsd:date ) } LIMIT 100
Example with bif:contains
Suppose there is the following query using bif:contains for date:
If ?date is of type xsd:date or xsd:dateTime and of valid syntax then bif:contains(?date, '"1945*"' ) will not found it, because it will be parsed at load/create and stored as SQL DATE value.
So if data are all accurate and typed properly then the filter is:
(?date >= xsd:date("1945-01-01") && ?date < xsd:date("1946-01-01"))
i.e. the query should be:
SELECT DISTINCT ?s ?date FROM <http://dbpedia.org> WHERE { ?s ?p ?date . FILTER( ?date >= xsd:date("1945-01-01") && ?date < xsd:date("1946-01-01") && (str(?p) != str(rdfs:label)) ) } LIMIT 10
If data falls, then the free-text will be OK for tiny examples but not for "big" cases because bif:contains(?date, '"1945*"') would require that less than 200 words in the table begins with 1945. Still, some data can be of accurate type and syntax so range comparison should be used for them and results aggregated via UNION.
If dates mention timezones then the application can chose the beginning and the end of the year in some timezones other than the default.
Let's take for example a created Linked Data View from relational data in Virtuoso. The RDF output therefor should have two graphs which reside in a quad storage named for ex.:
http://localhost:8890/rdfv_demo/quad_storage/default
Also the RDF is accessible over the SPARQL endpoint with the following query:
define input:storage <http://localhost:8890/rdfv_demo/quad_storage/default> SELECT * WHERE { ?s ?p ?o }
Now one could ask is there a way to define internally (once) that the quad storage should be included in queries to the SPARQL endpoint? So that the user does not have to define the input:storage explicitly in each query, like this:
http://localhost:8890/sparql?query=select * where { ?s ?p ?o }&default-graph-uri=NULL&named-graph-uri=NULL
All metadata about all RDF storages are kept in "system" graph <http://www.openlinksw.com/schemas/virtrdf#> ( namespace prefix virtrdf: ). Subjects of type virtrdf:QuadStorage are RDF storages. There are three of them by default:
SQL> SPARQL SELECT * FROM virtrdf: WHERE { ?s a virtrdf:QuadStorage }; s VARCHAR _______________________________________________________________________________ http://www.openlinksw.com/schemas/virtrdf#DefaultQuadStorage http://www.openlinksw.com/schemas/virtrdf#DefaultServiceStorage http://www.openlinksw.com/schemas/virtrdf#SyncToQuads 3 Rows. -- 3 msec.
There are two ways of using the Linked Data View from above in SPARQL endpoint without define input:storage:
SPARQL ALTER QUAD STORAGE virtrdf:DefaultQuadStorage . . .
Currently system metadata consist of three "levels":
QuadStorages contains only "symlinks" to maps, if you drop a storage you don't drop all mappings inside. If you drop the DefaultQuadStorage or some other built-in thing, it can be safely recovered by DB.DBA.RDF_AUDIT_METADATA, with first parameter set to 1. This will keep your own data intact. However we recommend to write a script that declares all your formats, Linked Data Views and storages, to be able to reproduce the configuration after any failures.
Virtuoso supports graph-level security, as described here but not subject-level or predicate-level. When exposing data that needs protected access, triples should be confined to private name graphs which are protected by ACLs using WebID.
Note, how you can use WebID to protect Virtuoso SPARQL endpoints.
Virtuoso Web Server has the capability to create extra listeners using the Conductor interface.
Interface: 0.0.0.0 Port: 8080 Http Host: my.example.com
[URIQA] DefaultHost = my.example.com:8080
The Virtuoso Entity Framework 3.5 ADO.Net Provider is current only list as a Visible control in the Visual Studio 2008 IDE as the current installers only create the necessary registry entries for Visual Studio 2008. To make it visible in the Visual Studio 2010's IDE the following registry settings need to be manually updated and manual addtions to some of the VS 2010 XML configuration files:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\8.0\DataProviders\{EE00F82B-C5A4-4073-8FF1-33F815C9801D} - and - HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\8.0\DataSources\{90FBCAF2-8F42-47CD-BF1A-88FF41173060}
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\10.0....
<add name="VirtuosoClient3 Data Provider" invariant="OpenLink.Data.Virtuoso" description=".NET Framework Data Provider for Virtuoso" type="OpenLink.Data.Virtuoso.VirtuosoClientFactory, virtado3, Version=6.2.3128.2, Culture=neutral, PublicKeyToken=391bf132017ae989" />
and copy is to the equivalent C:\WINDOWS\Microsoft.NET\Frameworks\v4.0.30128\CONFIG\machine.config location.
Visual Studio 2010 will then have the necessary information to locate and load the Virtuoso ADO.Net provider in its IDE.
The registry should typically contain the following entries for Visual Studio 2010 as a result:
Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}] @=".NET Framework Data Provider for Virtuoso" "AssociatedSource"="{4D90D7C5-69A6-43EE-83ED-59A0E442D260}" "CodeBase"="C:\\Windows\\assembly\\GAC_MSIL\\virtado3\\6.2.3128.1__391bf132017ae989\\virtado3.dll" "Description"="Provider_Description, OpenLink.Data.Virtuoso.DDEX.Net3.DDEXResources, virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" "DisplayName"="Provider_DisplayName, OpenLink.Data.Virtuoso.DDEX.Net3.DDEXResources, virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" "InvariantName"="OpenLink.Data.Virtuoso" "PlatformVersion"="2.0" "ShortDisplayName"="Provider_ShortDisplayName, OpenLink.Data.Virtuoso.DDEX.Net3.DDEXResources, virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" "Technology"="{77AB9A9D-78B9-4ba7-91AC-873F5338F1D2}" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects] [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IDSRefBuilder] @="Microsoft.VisualStudio.Data.Framework.DSRefBuilder" "Assembly"="Microsoft.VisualStudio.Data.Framework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataAsyncCommand] [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataCommand] [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataConnectionProperties] @="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoDataConnectionProperties" "Assembly"="virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataConnectionSupport] @="Microsoft.VisualStudio.Data.Framework.AdoDotNet.AdoDotNetConnectionSupport" "Assembly"="Microsoft.VisualStudio.Data.Framework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataConnectionUIControl] @="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoDataConnectionUIControl" "Assembly"="virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataConnectionUIProperties] @="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoDataConnectionProperties" "Assembly"="virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataMappedObjectConverter] [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataObjectIdentifierResolver] @="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoDataObjectIdentifierResolver" "Assembly"="virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataObjectSupport] @="Microsoft.VisualStudio.Data.Framework.DataObjectSupport" "Assembly"="Microsoft.VisualStudio.Data.Framework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" "XmlResource"="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoObjectSupport" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataSourceInformation] @="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoDataSourceInformation" "Assembly"="virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataTransaction] [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}\SupportedObjects\IVsDataViewSupport] @="Microsoft.VisualStudio.Data.Framework.DataViewSupport" "Assembly"="Microsoft.VisualStudio.Data.Framework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" "XmlResource"="OpenLink.Data.Virtuoso.DDEX.Net3.VirtuosoViewSupport" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataSources\{4D90D7C5-69A6-43EE-83ED-59A0E442D260}] @="OpenLink Virtuoso Data Source" "DefaultProvider"="{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}" [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataSources\{4D90D7C5-69A6-43EE-83ED-59A0E442D260}\SupportingProviders] [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\DataSources\{4D90D7C5-69A6-43EE-83ED-59A0E442D260}\SupportingProviders\{0886A2BB-03D0-4E00-8A3D-F235A5DC0F6D}] "Description"="DataSource_Description, OpenLink.Data.Virtuoso.DDEX.Net3.DDEXResources, virtado3, Version=6.2.3128.1, Culture=neutral, PublicKeyToken=391bf132017ae989"
The next Virtuoso releases, 6.3+ will support this new Visual Studio 2010 release out of the box.
The normalization of UNICODE3 accented chars in free-text index can be controlled by setting up the configuration parameter XAnyNormalization in the virtuoso.ini config file, section [I18N]. This parameter controls whether accented UNICODE characters should be converted to their non-accented base variants at the very beginning of free-text indexing or parsing a free-text query string. The parameter's value is an integer that is bitmask with only 2 bits in use atm:
If the parameter is required at all, the needed value is probably 3. So the fragment of virtuoso.ini is:
[I18N] XAnyNormalization=3
In some seldom case the value of 1 can be appropriate. The parameter should be set once before creating the database. If changed on the existing database, all free-text indexes that may contain non-ASCII data should be re-created. On a typical system, the parameter affects all text columns, XML columns, RDF literals and queries.
Strictly speaking, it affects not all of them but only items that use default "x-any" language or language derived from x-any such as "en" and "en-US" but if you haven't tried writing new C plugins for custom languages you should not look so deep.
As an example, with XAnyNormalization=3 once can get the following:
SQL>SPARQL INSERT IN <http://InternationalNSMs/> { <s> <sp> "Índio João Macapá Júnior Tôrres Luís Araújo José" ; <ru> "Он добавил картошки, посолил и поставил аквариум на огонь" . } INSERT INTO <http://InternationalNSMs/>, 2 (or less) triples -- done SQL> DB.DBA.RDF_OBJ_FT_RULE_ADD (null, null, 'InternationalNSMs.wb'); Done. -- 0 msec. SQL>vt_inc_index_db_dba_rdf_obj(); Done. -- 26 msec. SQL>SPARQL SELECT * FROM <http://InternationalNSMs/> WHERE { ?s ?p ?o } ORDER BY ASC (str(?o)) s sp Índio João Macapá Júnior Tôrres Luís Araújo José s ru Он добавил картошки, посолил и поставил аквариум на огонь 2 Rows. -- 2 msec. SQL> SPARQL SELECT * FROM <http://InternationalNSMs/> WHERE { ?s ?p ?o . ?o bif:contains "'Índio João Macapá Júnior Tôrres Luís Araújo José'" . } s sp Índio João Macapá Júnior Tôrres Luís Araújo José 1 Rows. -- 2 msec. SQL>SPARQL SELECT * FROM <http://InternationalNSMs/> WHERE { ?s ?p ?o . ?o bif:contains "'Indio Joao Macapa Junior Torres Luis Araujo Jose'" . } s sp Índio João Macapá Júnior Tôrres Luís Araújo José 1 Rows. -- 1 msec. SQL> SPARQL SELECT * FROM <http://InternationalNSMs/> WHERE { ?s ?p ?o . ?o bif:contains "'поставил аквариум на огонь'" . } s ru Он добавил картошки, посолил и поставил аквариум на огонь
There was also request for function that normalizes characters in strings as free-text engine will do with XAnyNormalization=3 , the function will be provided as a separate patch and depends on this specific patch.
Suppose we have the following scenario:
http://host:port/DAV/home/<user-name>/<rdf-sink-folder>/ -- So in our example it should be: http://localhost:8890/DAV/home/john/MySinkFolder/
![]() |
Figure: 1.5.12.1. |
![]() |
Figure: 1.5.12.1. |
http:///local.virt/DAV/home/<user-name>/<rdf-sink-folder>/<resource> -- So in our example it will be: http:///local.virt/DAV/home/john/MySinkFolder/data.rdf
SELECT * FROM <http://local.virt/DAV/home/john/MySinkFolder/data.rdf> WHERE { ?s ?p ?o }
![]() |
Figure: 1.5.12.1. |
![]() |
Figure: 1.5.12.2. |
SQL> DAV_PROP_SET ('/DAV/home/<user-name>/<rdf-sink-folder>/', 'virt:rdf_graph', iri, <user-name>, <password>); -- So in our example it should be: SQL> DAV_PROP_SET ('/DAV/home/john/MySinkFolder/', 'virt:rdf_graph', 'http://mydata.com', 'john', '1');
SQL> SELECT DAV_PROP_GET ('/DAV/home/<user-name>/<your-rdf-sink-folder>/', 'virt:rdf_graph',<user-name>, <password>); -- So in our example it should be: SQL> SELECT DAV_PROP_GET ('/DAV/home/john/MySinkFolder/', 'virt:rdf_graph','john', '1'); Query result: DAV_PROP_GET http://localhost:8890/DAV/home/john/MySinkFolder/ No. of rows in result: 1
Assume a given graph where triples are comprised of property values that are mixed across URI References and Typed Literals as exemplified by the results of the query below:
SELECT DISTINCT ?sa ?oa FROM <http://ucb.com/nbeabase> WHERE { ?sa a <http://ucb.com/nbeabase/resource/Batch> . ?sa <http://ucb.com/nbeabase/resource/chemAbsNo> ?oa . FILTER regex(?oa, '-','i') }
You can use the following SPARUL pattern to harmonize the property values across relevant triples in a specific graph, as shown below:
SQL> SPARQL INSERT INTO GRAPH <http://ucb.com/nbeabase> { ?sa <http://ucb.com/nbeabase/resource/sampleId> `str (?oa)` } WHERE { ?sa <http://ucb.com/nbeabase/resource/chemAbsNo> ?oa . FILTER regex(?oa, '-','i') }
The cluster cl_exec() function is used to perform a checkpoint across all node of a Virtuoso cluster as follows:
SQL>cl_exec ('checkpoint');
This typically needs to be run after loading RDF datasets into a Virtuoso cluster to prevent lose of data when the cluster is restarted.
Assume a given query which uses pragma output:format '_JAVA_' with CONSTRUCT:
SPARQL DEFINE output:format '_JAVA_' CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER (?s = iri(?::0)) } LIMIT 1
In order to work correctly, the query should be modified to:
SPARQL DEFINE output:format '_JAVA_' CONSTRUCT { `iri(?::0)` ?p ?o } WHERE { `iri(?::0)` ?p ?o } LIMIT 1
Equivalent variant of the query is also:
SPARQL DEFINE output:format '_JAVA_' CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER (?s = iri(?::0)) } LIMIT 1
Since SPARUL updates are generally not meant to be transactional, it is best to run these in:
SQL> log_enable (2);
mode, which commits every operation as it is done. This prevents one from running out of rollback space. Also for bulk updates, transaction logging can be turned off. If so, one should do a manual checkpoint after the operation to ensure persistence across server restart since there is no roll forward log.
Alternatively, the "TransactionAfterImageLimit" parameter can be set in the virtuoso.ini config file to a higher value than its 50MB default:
#virtuoso.ini ... [Parameters] ... TransactionAfterImageLimit = N bytes default 50000000 ...
The following code is an example of loading data via crawler with special function to generate link for downloading:
create procedure EUROPEANA_STORE ( in _host varchar, in _url varchar, in _root varchar, inout _content varchar, in _s_etag varchar, in _c_type varchar, in store_flag int := 1, in udata any := null, in lev int := 0) { declare url varchar; declare xt, xp any; declare old_mode int; xt := xtree_doc (_content, 2); xp := xpath_eval ('//table//tr/td/a[@href]/text()', xt, 0); commit work; old_mode := log_enable (3,1); foreach (any u in xp) do { u := cast (u as varchar); url := sprintf ('http://semanticweb.cs.vu.nl/europeana/api/export_graph?graph=%U&mimetype=default&format=turtle', u); dbg_printf ('%s', u); { declare continue handler for sqlstate '*' { dbg_printf ('ERROR: %s', __SQL_MESSAGE); }; SPARQL LOAD ?:url into GRAPH ?:u; } } log_enable (old_mode, 1); return WS.WS.LOCAL_STORE (_host, _url, _root, _content, _s_etag, _c_type, store_flag, 0); }
Assume a given attempts to get an exact mapping for the literal "1950" using bif:contains:
SPARQL SELECT DISTINCT ?s ?o FROM <http://dbpedia.org> WHERE { ?s ?p ?o . FILTER( bif:contains (?o, '"1950"') && isLiteral(?o) && ( str(?p) ! = rdfs:label || str(?p) != foaf:name && ( ?o='1950') ) }
As an integer 1950 or date 1950-01-01 are not texts, they are not in free-text index and thus invisible for CONTAINS free-text predicate.
A possible way to make them visible that way is to introduce an additional RDF predicate that will contain objects of the triples in question, converted to strings via str() function.
Thus better results will be approached: if searches about dates are frequent then a new predicate can have date/datetime values extracted from texts, eliminating the need for bif:contains.
Therefor, the query from above should be changed to:
SPARQL SELECT DISTINCT ?s ?o FROM <http://dbpedia.org> WHERE { ?s ?p ?o . FILTER ( isLiteral(?o) && ( str(?p) != str(rdfs:label) || str(?p) != foaf:name ) && str(?o) in ("1950", "1950-01-01")) }
The SPARQL query should use the cert:hex and cert:decimal in order to get to the values, so for ex:
PREFIX cert: <http://www.w3.org/ns/auth/cert#> PREFIX rsa: <http://www.w3.org/ns/auth/rsa#> SELECT ?webid FROM <http://webid.myxwiki.org/xwiki/bin/view/XWiki/homepw4> WHERE { [] cert:identity ?webid ; rsa:modulus ?m ; rsa:public_exponent ?e . ?m cert:hex "b520f38479f5803a7ab33233155eeef8ad4e1f575b603f7780f3f60ceab1\n34618fbe117539109c015c5f959b497e67c1a3b2c96e5f098bb0bf2a6597\n779d26f55fe8d320de7af0562fd2cd067dbc9d775b22fc06e63422717d00\na6801dedafd7b54a93c3f4e59538475673972e524f4ec2a3667d0e1ac856\nd532e32bf30cef8c1adc41718920568fbe9f793daeeaeeaa7e8367b7228a\n895a6cf94545a6f6286693277a1bc7750425ce6c35d570e89453117b88ce\n24206afd216a705ad08b7c59\n"^^xsd:string . ?e cert:decimal "65537"^^xsd:string }
See details here.
See details here.
When you install Virtuoso, it's reasoner and highly scalable inference capabilities may not be obvious. Typical cases involve using rdfs:subClassOf predicates in queries and wondering why reasoning hasn't occurred in line with the semantics defined in RDF Schema.
The experience applies when using more sophisticated predicates from OWL such as owl:equivalentProperty, owl:equivalentClass, owl:sameAs, owl:SymmetricalProperty, owl:inverseOf etc ...
Virtuoso implemented inference rules processing in a loosely coupled manner that allow users to conditionally apply inference context (via rules) to SPARQL queries. Typically, you have to create these rules following steps outlined here.
This tips and tricks note provides a shortcut for setting up and exploring RDF Schema and OWL reasoning once you've installed the Virtuoso Faceted Browser VAD package.
Assume the following arbitrary query:
SPARQL define output:format "NT" CONSTRUCT { ?s a ?t } FROM virtrdf: WHERE { ?s a ?t };
For iteration over result-set of an arbitrary query, use exec_next() in a loop that begins with exec() with cursor output variable as an argument and ends with exec_close() after it is out of data.
Assume the following SPARQL query:
CONSTRUCT { ?s ?p ?o } FROM ?context WHERE { ?s ?p ?o }
To bind the named graph context of the query from above, the best solution due to performance implications, is to change the syntax of the query as:
CONSTRUCT { ?s ?p ?o } WHERE { graph `iri(??)` { ?s ?p ?o } }
Note: In case of using "FROM clause", it needs a constant in order to check at the compile time whether the IRI refers to a graph or a graph group:
CONSTRUCT { ?s ?p ?o } FROM `iri(??)` WHERE { ?s ?p ?o }
CONSTRUCT { ?s ?p ?o } FROM iri(??) WHERE { ?s ?p ?o }
The following example shows different methods for insert binary data to Virtuoso RDF storage in plain queries and with parameter binding via ADO.NET calls:
# Test_Bin.cs using System; using System.Runtime.InteropServices; using System.Text; using System.Data; using OpenLink.Data.Virtuoso; #if ODBC_CLIENT namespace OpenLink.Data.VirtuosoOdbcClient #elif CLIENT namespace OpenLink.Data.VirtuosoClient #else namespace OpenLink.Data.VirtuosoTest #endif { class Test_Bin { [STAThread] static void Main(string[] args) { IDataReader myread = null; IDbConnection c; c = new VirtuosoConnection("HOST=localhost:1111;UID=dba;PWD=dba;"); IDbCommand cmd = c.CreateCommand(); int ros; try { c.Open(); cmd.CommandText = "sparql clear graph <ado.bin>"; cmd.ExecuteNonQuery(); //insert binary as base64Binary cmd.CommandText = "sparql insert into graph <ado.bin> { <res1> <attr> \"GpM7\"^^<http://www.w3.org/2001/XMLSchema#base64Binary> }"; cmd.ExecuteNonQuery(); //insert binary as hexBinary cmd.CommandText = "sparql insert into graph <ado.bin> { <res2> <attr> \"0FB7\"^^<http://www.w3.org/2001/XMLSchema#hexBinary> }"; cmd.ExecuteNonQuery(); //prepare for insert with parameter binding cmd.CommandText = "sparql define output:format '_JAVA_' insert into graph <ado.bin> { `iri($?)` <attr> `bif:__rdf_long_from_batch_params($?,$?,$?)` }"; //bind parameters for insert binary as base64Binary IDbDataParameter param = cmd.CreateParameter(); param.ParameterName = "p1"; param.DbType = DbType.AnsiString; param.Value = "res3"; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p2"; param.DbType = DbType.Int32; param.Value = 4; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p3"; param.DbType = DbType.AnsiString; param.Value = "GpM7"; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p4"; param.DbType = DbType.AnsiString; param.Value = "http://www.w3.org/2001/XMLSchema#base64Binary"; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); cmd.Parameters.Clear(); //bind parameters for insert binary as hexBinary param = cmd.CreateParameter(); param.ParameterName = "p1"; param.DbType = DbType.AnsiString; param.Value = "res4"; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p2"; param.DbType = DbType.Int32; param.Value = 4; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p3"; param.DbType = DbType.AnsiString; param.Value = "0FB7"; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p4"; param.DbType = DbType.AnsiString; param.Value = "http://www.w3.org/2001/XMLSchema#hexBinary"; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); cmd.Parameters.Clear(); //bind parameters for insert binary as byte[] param = cmd.CreateParameter(); param.ParameterName = "p1"; param.DbType = DbType.AnsiString; param.Value = "res5"; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p2"; param.DbType = DbType.Int32; param.Value = 3; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p3"; param.DbType = DbType.Binary; byte[] bin_val = {0x01, 0x02, 0x03, 0x04, 0x05}; param.Value = bin_val; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p4"; param.DbType = DbType.AnsiString; param.Value = System.DBNull.Value; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); cmd.Parameters.Clear(); //execute select and check the results cmd.CommandText = "sparql SELECT ?s ?o FROM <ado.bin> WHERE {?s ?p ?o}"; ; myread = cmd.ExecuteReader(); int r = 0; while (myread.Read()) { Console.WriteLine("=== ROW === "+r); for (int i = 0; i < myread.FieldCount; i++) { string s; if (myread.IsDBNull(i)) Console.Write("N/A|\n"); else { object o = myread.GetValue(i); Type t = myread.GetFieldType(i); s = myread.GetString(i); Console.Write(s + "["); if (o is SqlExtendedString) { SqlExtendedString se = (SqlExtendedString)o; Console.Write("IriType=" + se.IriType + ";StrType=" + se.StrType + ";Value=" + se.ToString()); Console.Write(";ObjectType=" + o.GetType() + "]|\n"); } else if (o is SqlRdfBox) { SqlRdfBox se = (SqlRdfBox)o; Console.Write("Lang=" + se.StrLang + ";Type=" + se.StrType + ";Value=" + se.Value); Console.Write(";ObjectType=" + o.GetType() + "]|\n"); object v = se.Value; if (v is System.Byte[]) { byte[] vb = (byte[])v; for (int z = 0; z < vb.Length; z++) { Console.WriteLine(""+z+"="+vb[z]); } } } else Console.Write(o.GetType() + "]|\n"); } } r++; } } catch (Exception e) { Console.WriteLine("{0} Exception caught.", e); } finally { // if (myread != null) // myread.Close(); if (c.State == ConnectionState.Open) c.Close(); } } } }
Output log for example is in the log.txt:
# log.txt === ROW === 0 res1[IriType=IRI;StrType=IRI;Value=res1;ObjectType=OpenLink.Data.Virtuoso.SqlExtendedString]| GpM7[Lang=;Type=http://www.w3.org/2001/XMLSchema#base64Binary;Value=GpM7;ObjectType=OpenLink.Data.Virtuoso.SqlRdfBox]| === ROW === 1 res2[IriType=IRI;StrType=IRI;Value=res2;ObjectType=OpenLink.Data.Virtuoso.SqlExtendedString]| 0FB7[Lang=;Type=http://www.w3.org/2001/XMLSchema#hexBinary;Value=0FB7;ObjectType=OpenLink.Data.Virtuoso.SqlRdfBox]| === ROW === 2 res3[IriType=IRI;StrType=IRI;Value=res3;ObjectType=OpenLink.Data.Virtuoso.SqlExtendedString]| GpM7[Lang=;Type=http://www.w3.org/2001/XMLSchema#base64Binary;Value=GpM7;ObjectType=OpenLink.Data.Virtuoso.SqlRdfBox]| === ROW === 3 res4[IriType=IRI;StrType=IRI;Value=res4;ObjectType=OpenLink.Data.Virtuoso.SqlExtendedString]| 0FB7[Lang=;Type=http://www.w3.org/2001/XMLSchema#hexBinary;Value=0FB7;ObjectType=OpenLink.Data.Virtuoso.SqlRdfBox]| === ROW === 4 res5[IriType=IRI;StrType=IRI;Value=res5;ObjectType=OpenLink.Data.Virtuoso.SqlExtendedString]| 0102030405[System.Byte[]]|
The following example shows how to insert RDF Data from Visual Studio to Virtuoso:
using System; using System.Runtime.InteropServices; using System.Text; using System.Data; using OpenLink.Data.Virtuoso; #if ODBC_CLIENT namespace OpenLink.Data.VirtuosoOdbcClient #elif CLIENT namespace OpenLink.Data.VirtuosoClient #else namespace OpenLink.Data.VirtuosoTest #endif { class Test_Insert { [STAThread] static void Main(string[] args) { IDataReader myread = null; IDbConnection c; c = new VirtuosoConnection("HOST=localhost:1111;UID=dba;PWD=dba;Charset=UTF-8"); IDbCommand cmd = c.CreateCommand(); int ros; try { c.Open(); cmd.CommandText = "sparql clear graph <ado.net>"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P01> \"131\"^^<http://www.w3.org/2001/XMLSchema#short> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P02> \"1234\"^^<http://www.w3.org/2001/XMLSchema#integer> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P03> \"12345.12\"^^<http://www.w3.org/2001/XMLSchema#float> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P04> \"123456.12\"^^<http://www.w3.org/2001/XMLSchema#double> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P05> \"123456.12\"^^<http://www.w3.org/2001/XMLSchema#decimal> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P06> \"01020304\"^^<http://www.w3.org/2001/XMLSchema#hexBinary> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P07> \"01.20.1980T04:51:13\"^^<http://www.w3.org/2001/XMLSchema#dateTime> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P08> \"01.20.1980\"^^<http://www.w3.org/2001/XMLSchema#date> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P09> \"01:20:19\"^^<http://www.w3.org/2001/XMLSchema#time> }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql insert into graph <ado.net> { <a> <P10> \"test\" }"; cmd.ExecuteNonQuery(); cmd.CommandText = "sparql define output:format '_JAVA_' insert into graph <ado.net> { <b> `iri($?)` `bif:__rdf_long_from_batch_params($?,$?,$?)` }"; //add Object URI add_triple(cmd, "S01", 1, "test1", null); //add Object BNode add_triple(cmd, "S02", 1, "_:test2", null); //add Literal add_triple(cmd, "S03", 3, "test3", null); //add Literal with Datatype add_triple(cmd, "S04", 4, "1234", "http://www.w3.org/2001/XMLSchema#integer"); //add Literal with Lang add_triple(cmd, "S05", 5, "test5", "en"); add_triple(cmd, "S06", 3, (short)123, null); add_triple(cmd, "S07", 3, 1234, null); add_triple(cmd, "S08", 3, (float)12345.12, null); add_triple(cmd, "S09", 3, 123456.12, null); add_triple(cmd, "S10", 3, new DateTime(2001, 02, 23, 13, 44, 51, 234), null); add_triple(cmd, "S11", 3, new DateTime(2001, 02, 24), null); add_triple(cmd, "S12", 3, new TimeSpan(19, 41, 23), null); add_triple(cmd, "S13", 4, "GpM7", "http://www.w3.org/2001/XMLSchema#base64Binary"); add_triple(cmd, "S14", 4, "0FB7", "http://www.w3.org/2001/XMLSchema#hexBinary"); byte[] bin_val = { 0x01, 0x02, 0x03, 0x04, 0x05 }; add_triple(cmd, "S15", 3, bin_val, null); } catch (Exception e) { Console.WriteLine("{0} Exception caught.", e); } finally { if (c.State == ConnectionState.Open) c.Close(); } } static void add_triple(IDbCommand cmd, string sub, int ptype, object val, string val_add) { cmd.Parameters.Clear(); IDbDataParameter param = cmd.CreateParameter(); param.ParameterName = "p1"; param.DbType = DbType.AnsiString; param.Value = sub; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p2"; param.DbType = DbType.Int32; param.Value = ptype; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p3"; if (val != null && val.GetType() == typeof (System.String)) param.DbType = DbType.AnsiString; param.Value = val; cmd.Parameters.Add(param); param = cmd.CreateParameter(); param.ParameterName = "p4"; param.DbType = DbType.AnsiString; param.Value = val_add; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); } } }
The default describe mode works only if subject has a type/class. To get any anonymous subject described CBD mode should be used:
$ curl -i -L -H "Accept: application/rdf+xml" http://lod.openlinksw.com/describe/?url=http%3A%2F%2Fwww.mpii.de%2Fyago%2Fresource%2FEddie%255FMurphy HTTP/1.1 303 See Other Date: Mon, 21 Mar 2011 14:24:36 GMT Server: Virtuoso/06.02.3129 (Linux) x86_64-generic-linux-glibc25-64 VDB Content-Type: text/html; charset=UTF-8 Accept-Ranges: bytes TCN: choice Vary: negotiate,accept,Accept-Encoding Location: http://lod.openlinksw.com/sparql?query=%20DESCRIBE%20%3Chttp%3A%2F%2Fwww.mpii.de%2Fyago%2Fresource%2FEddie%255FMurphy%3E&format=application% 2Frdf%2Bxml Content-Length: 0 HTTP/1.1 200 OK Date: Mon, 21 Mar 2011 14:24:37 GMT Server: Virtuoso/06.02.3129 (Linux) x86_64-generic-linux-glibc25-64 VDB Accept-Ranges: bytes Content-Type: application/rdf+xml; charset=UTF-8 Content-Length: 467967 <?xml version="1.0" encoding="utf-8" ?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"> <rdf:Description rdf:about="http://www.mpii.de/yago/resource/MTV%5FMovie%5FAward%5Ffor%5FBest%5FComedic%5FPerformance"><n0pred:hasInternalWikipediaLinkTo xmlns:n0pred="http://www.mpii.de/yago/resource/" rdf:resource="http://www.mpii.de/yago/resource/Eddie%5FMurphy"/></rdf:Description> <rdf:Description rdf:about="http://www.mpii.de/yago/resource/#fact_23536547421"><rdf:subject rdf:resource="http://www.mpii.de/yago/resource/Eddie%5FMurphy"/></rdf:Description> <rdf:Description rdf:about="http://www.mpii.de/yago/resource/#fact_23536896725"><rdf:object rdf:resource="http://www.mpii.de/yago/resource/Eddie%5FMurphy"/></rdf:Description> ...
Assume the Virtuoso server is not responding to HTTP requests although SQL connection is working. In order to determine what activity is being performed that might account for this:
SQL> status(''); REPORT VARCHAR _______________________________________________________________________________ OpenLink Virtuoso VDB Server Version 06.02.3129-pthreads for Linux as of Mar 16 2011 Registered to Uriburner (Personal Edition, unlimited connections) Started on: 2011/03/17 10:49 GMT+60 Database Status: File size 0, 37598208 pages, 7313125 free. 1000000 buffers, 993399 used, 76771 dirty 0 wired down, repl age 25548714 0 w. io 0 w/crsr. Disk Usage: 2642884 reads avg 4 msec, 30% r 0% w last 1389 s, 1557572 writes, 15331 read ahead, batch = 79. Autocompact 308508 in 219226 out, 28% saved. Gate: 71130 2nd in reads, 0 gate write waits, 0 in while read 0 busy scrap. Log = virtuoso.trx, 14922248 bytes VDB: 0 exec 0 fetch 0 transact 0 error 1757362 pages have been changed since last backup (in checkpoint state) Current backup timestamp: 0x0000-0x00-0x00 Last backup date: unknown Clients: 5 connects, max 2 concurrent RPC: 116 calls, -1 pending, 1 max until now, 0 queued, 2 burst reads (1%), 0 second brk=9521074176 Checkpoint Remap 331113 pages, 0 mapped back. 1180 s atomic time. DB master 37598208 total 7313125 free 331113 remap 40593 mapped back temp 569856 total 569851 free Lock Status: 52 deadlocks of which 0 2r1w, 86078 waits, Currently 1 threads running 0 threads waiting 0 threads in vdb. Pending: 25 Rows. -- 1274 msec. SQL>
$ isql 1111 dba <password> -D DEBUG> info threads
SQL> txn_killall(); Done. -- 866 msec.
The following options are supported for CXML link behavior in the SPARQL URL Pattern:
# CXML_redir_for_subjs=&CXML_redir_for_hrefs=&: http://lod.openlinksw.com/sparql?default-graph-uri=&should-sponge=&query=SELECT+DISTINCT+%3Fcafe+%3Flat+%3Flong+%3Fcafename+%3Fchurchname++%28+bif%3Around%28bif%3Ast_distance+%28%3Fchurchgeo%2C+%3Fcafegeo%29%29+%29++WHERE++{++++%3Fchurch+a+lgv%3Aplace_of_worship+.++++%3Fchurch+geo%3Ageometry+%3Fchurchgeo+.++++%3Fchurch+lgv%3Aname+%3Fchurchname+.++++%3Fcafe+a+lgv%3Acafe+.++++%3Fcafe+lgv%3Aname+%3Fcafename+.++++%3Fcafe+geo%3Ageometry+%3Fcafegeo+.++++%3Fcafe+geo%3Alat+%3Flat+.++++%3Fcafe+geo%3Along+%3Flong+.++++FILTER+%28+bif%3Ast_intersects+%28%3Fchurchgeo%2C+bif%3Ast_point+%282.3498%2C48.853%29%2C5%29++%26%26+bif%3Ast_intersects+%28%3Fcafegeo%2C+%3Fchurchgeo%2C+0.2%29+%29+}+LIMIT+50&debug=on&timeout=&format=text%2Fhtml&CXML_redir_for_subjs=&CXML_redir_for_hrefs=&save=display&fname=
# CXML_redir_for_subjs=&CXML_redir_for_hrefs=121: http://lod.openlinksw.com/sparql?default-graph-uri=&should-sponge=&query=SELECT+DISTINCT+%3Fcafe+%3Flat+%3Flong+%3Fcafename+%3Fchurchname++%28+bif%3Around%28bif%3Ast_distance+%28%3Fchurchgeo%2C+%3Fcafegeo%29%29+%29++WHERE++{++++%3Fchurch+a+lgv%3Aplace_of_worship+.++++%3Fchurch+geo%3Ageometry+%3Fchurchgeo+.++++%3Fchurch+lgv%3Aname+%3Fchurchname+.++++%3Fcafe+a+lgv%3Acafe+.++++%3Fcafe+lgv%3Aname+%3Fcafename+.++++%3Fcafe+geo%3Ageometry+%3Fcafegeo+.++++%3Fcafe+geo%3Alat+%3Flat+.++++%3Fcafe+geo%3Along+%3Flong+.++++FILTER+%28+bif%3Ast_intersects+%28%3Fchurchgeo%2C+bif%3Ast_point+%282.3498%2C48.853%29%2C5%29++%26%26+bif%3Ast_intersects+%28%3Fcafegeo%2C+%3Fchurchgeo%2C+0.2%29+%29+}+LIMIT+50&debug=on&timeout=&format=text%2Fhtml&CXML_redir_for_subjs=&CXML_redir_for_hrefs=121&save=display&fname=
# CXML_redir_for_subjs=&CXML_redir_for_hrefs=LOCAL_PIVOT: http://lod.openlinksw.com/sparql?default-graph-uri=&should-sponge=&query=SELECT+DISTINCT+%3Fcafe+%3Flat+%3Flong+%3Fcafename+%3Fchurchname++%28+bif%3Around%28bif%3Ast_distance+%28%3Fchurchgeo%2C+%3Fcafegeo%29%29+%29++WHERE++{++++%3Fchurch+a+lgv%3Aplace_of_worship+.++++%3Fchurch+geo%3Ageometry+%3Fchurchgeo+.++++%3Fchurch+lgv%3Aname+%3Fchurchname+.++++%3Fcafe+a+lgv%3Acafe+.++++%3Fcafe+lgv%3Aname+%3Fcafename+.++++%3Fcafe+geo%3Ageometry+%3Fcafegeo+.++++%3Fcafe+geo%3Alat+%3Flat+.++++%3Fcafe+geo%3Along+%3Flong+.++++FILTER+%28+bif%3Ast_intersects+%28%3Fchurchgeo%2C+bif%3Ast_point+%282.3498%2C48.853%29%2C5%29++%26%26+bif%3Ast_intersects+%28%3Fcafegeo%2C+%3Fchurchgeo%2C+0.2%29+%29+}+LIMIT+50&debug=on&timeout=&format=text%2Fhtml&CXML_redir_for_subjs=&CXML_redir_for_hrefs=LOCAL_PIVOT&save=display&fname=
# CXML_redir_for_subjs=&CXML_redir_for_hrefs=LOCAL_TTL: http://lod.openlinksw.com/sparql?default-graph-uri=&should-sponge=&query=SELECT+DISTINCT+%3Fcafe+%3Flat+%3Flong+%3Fcafename+%3Fchurchname++%28+bif%3Around%28bif%3Ast_distance+%28%3Fchurchgeo%2C+%3Fcafegeo%29%29+%29++WHERE++{++++%3Fchurch+a+lgv%3Aplace_of_worship+.++++%3Fchurch+geo%3Ageometry+%3Fchurchgeo+.++++%3Fchurch+lgv%3Aname+%3Fchurchname+.++++%3Fcafe+a+lgv%3Acafe+.++++%3Fcafe+lgv%3Aname+%3Fcafename+.++++%3Fcafe+geo%3Ageometry+%3Fcafegeo+.++++%3Fcafe+geo%3Alat+%3Flat+.++++%3Fcafe+geo%3Along+%3Flong+.++++FILTER+%28+bif%3Ast_intersects+%28%3Fchurchgeo%2C+bif%3Ast_point+%282.3498%2C48.853%29%2C5%29++%26%26+bif%3Ast_intersects+%28%3Fcafegeo%2C+%3Fchurchgeo%2C+0.2%29+%29+}+LIMIT+50&debug=on&timeout=&format=text%2Fhtml&CXML_redir_for_subjs=&CXML_redir_for_hrefs=LOCAL_TTL&save=display&fname=
# CXML_redir_for_subjs=&CXML_redir_for_hrefs=LOCAL_CXML: http://lod.openlinksw.com/sparql?default-graph-uri=&should-sponge=&query=SELECT+DISTINCT+%3Fcafe+%3Flat+%3Flong+%3Fcafename+%3Fchurchname++%28+bif%3Around%28bif%3Ast_distance+%28%3Fchurchgeo%2C+%3Fcafegeo%29%29+%29++WHERE++{++++%3Fchurch+a+lgv%3Aplace_of_worship+.++++%3Fchurch+geo%3Ageometry+%3Fchurchgeo+.++++%3Fchurch+lgv%3Aname+%3Fchurchname+.++++%3Fcafe+a+lgv%3Acafe+.++++%3Fcafe+lgv%3Aname+%3Fcafename+.++++%3Fcafe+geo%3Ageometry+%3Fcafegeo+.++++%3Fcafe+geo%3Alat+%3Flat+.++++%3Fcafe+geo%3Along+%3Flong+.++++FILTER+%28+bif%3Ast_intersects+%28%3Fchurchgeo%2C+bif%3Ast_point+%282.3498%2C48.853%29%2C5%29++%26%26+bif%3Ast_intersects+%28%3Fcafegeo%2C+%3Fchurchgeo%2C+0.2%29+%29+}+LIMIT+50&debug=on&timeout=&format=text%2Fhtml&CXML_redir_for_subjs=&CXML_redir_for_hrefs=LOCAL_CXML&save=display&fname=
To replicate all graphs ( except the system graph http://www.openlinksw.com/schemas/virtrdf# ), one should use http://www.openlinksw.com/schemas/virtrdf#rdf_repl_all as graph IRI:
SQL> DB.DBA.RDF_RDF_REPL_GRAPH_INS ('http://www.openlinksw.com/schemas/virtrdf#rdf_repl_all');
The best method to get a random sample of all triples for a subset of all the resources of a SPARQL endpoint, is decimation in its original style:
SELECT ?s ?p ?o FROM <some-graph> WHERE { ?s ?p ?o . FILTER ( 1 > bif:rnd (10, ?s, ?p, ?o) ) }
By tweaking first argument of bif:rnd() and the left side of the inequality you can tweak decimation ratio from 1/10 to the desired value. What's important is to know that the SQL optimizer has a right to execute bif:rnd (10) only once at the beginning of the query, so we had to pass additional three arguments that can be known only when a table row is fetched so bif:rnd (10, ?s, ?p, ?o) is calculated for every row and thus any given row is either returned or ignored independently from others.
However, bif:rnd (10, ?s, ?p, ?o) contains a subtle inefficiency. In RDF store, graph nodes are stored as numeric IRI IDs and literal objects can be stored in a separate table. The call of an SQL function needs arguments of traditional SQL datatypes, so the query processor will extract the text of IRI for each node and the full value for each literal object. That is significant waste of time. The workaround is:
SPARQL SELECT ?s ?p ?o FROM <some-graph> WHERE { ?s ?p ?o . FILTER ( 1> <SHORT_OR_LONG::bif:rnd> (10, ?s, ?p, ?o)) }
This tells the SPARQL front-end to omit redundant conversions of values.
To replicate all graphs ( except the system graph http://www.openlinksw.com/schemas/virtrdf# ), one should use http://www.openlinksw.com/schemas/virtrdf#rdf_repl_all as graph IRI:
SQL> DB.DBA.RDF_RDF_REPL_GRAPH_INS ('http://www.openlinksw.com/schemas/virtrdf#rdf_repl_all');
The following example demonstrates how to use SPARQL in order to make Meshups:
PREFIX dbo: <http://dbpedia.org/ontology/> PREFIX rtb: <http://www.openlinksw.com/schemas/oat/rdftabs#> CONSTRUCT { ?museum geo:geometry ?museumgeo ; rtb:useMarker 'star' ; foaf:name ?musname; rdfs:comment ?muscomment. ?edu geo:geometry ?edugeo ; rtb:useMarker 'book' ; foaf:name ?eduname; rdfs:comment ?educomment. ?wh geo:geometry ?whgeo; rtb:useMarker '03'; foaf:name ?whname; rdfs:comment ?whcomment. } WHERE { { ?museum a dbo:Museum; geo:geometry ?museumgeo; foaf:name ?musname; rdfs:comment ?muscomment. filter (lang(?musname)='en' && lang(?muscomment)='en') } UNION { ?edu a dbo:University; geo:geometry ?edugeo; foaf:name ?eduname; rdfs:comment ?educomment. filter (lang(?eduname)='en' && lang(?educomment)='en') } UNION { ?wh a dbo:WorldHeritageSite; geo:geometry ?whgeo; rdfs:label ?whname; rdfs:comment ?whcomment. filter (lang(?whname)='en' && lang(?whcomment)='en') } }
The net_meter utility is a SQL procedure that runs a network test procedure on every host of the cluster. The network test procedure sends a message to every other host of the cluster and waits for the replies from each host. After the last reply is received the action is repeated. This results in a symmetrical load of the network, all points acting as both clients and servers to all other points.
net_meter ( in n_threads int, in n_batches int, in bytes int, in ops_per_batch int)
The parameters have the following meaning:
Assume anuser has run 2 sets of tests on a cluster:
The first one was 1 thread, 1000 batches, 1000 bytes per exchange, 1 operation per batch:
SQL> net_meter (1, 1000, 1000, 1); round_trips MBps REAL REAL _______________________________________ 1245.393315542000254 2.489418401123078 1 Rows. -- 39345 msec.
resulted in a measured throughput of 2.5 MBps
The second one was 1 thread, 5000 batches, 10000 bytes per exchange, 1 operation per batch:
SQL> net_meter (1, 5000, 10000, 1); round_trips MBps REAL REAL ___________________________________________ 15915.291672080031181 305.017186586494738 1 Rows. -- 15394 msec.
resulted in a measured throughput of 305 MBps.
This indicates that the user's network is slow when sending multiple short messages.
When using the ingestion you should check the:
status('cluster');
command a few times and check the XX KB/s amount which should be around or above the 2500 mark.
SPARQL INSERT can be done using the LOAD command:
SPARQL INSERT INTO <..> { .... } [[FROM ...] { ... }] SPARQL LOAD <x> [INTO <y>] -- <ResourceURL> will be the Graph IRI of the loaded data: SPARQL LOAD <ResourceURL>
In order to load data from resource URL for ex: http://www.w3.org/People/Berners-Lee/card#i , execute from isql the following command:
SQL> SPARQL LOAD <http://www.w3.org/People/Berners-Lee/card#i>; callret-0 VARCHAR _______________________________________________________________________________ Load <http://www.w3.org/People/Berners-Lee/card#i> into graph <http://www.w3.org/People/Berners-Lee/card#i> -- done 1 Rows. -- 703 msec. SQL>
SPARQL PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX sioc: <http://rdfs.org/sioc/ns#> SELECT ?x ?p ?o FROM <http://mygraph.com> WHERE { ?x rdf:type sioc:User . ?x ?p ?o. ?x sioc:id ?id . FILTER REGEX(str(?id), "^King") } ORDER BY ?x
SQL>SPARQL LOAD bif:concat ("http://", bif:registry_get("URIQADefaultHost"), "/DAV/tmp/listall.rq") into graph <http://myNewGraph.com>; callret-0 VARCHAR _______________________________________________________________________________ Load <http://localhost:8890/DAV/tmp/listall.rq> into graph <http://myNewGraph.com> -- done 1 Rows. -- 321 msec.
SQL>SPARQL INSERT INTO graph <http://mygraph.com> { <http://myopenlink.net/dataspace/Kingsley#this> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://rdfs.org/sioc/ns#User> . <http://myopenlink.net/dataspace/Kingsley#this> <http://rdfs.org/sioc/ns#id> <Kingsley> . <http://myopenlink.net/dataspace/Caroline#this> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://rdfs.org/sioc/ns#User> . <http://myopenlink.net/dataspace/Caroline#this> <http://rdfs.org/sioc/ns#id> <Caroline> . };
The following script demonstrates the use of custom stored procedures for deleting graph(s). It first creates a table GRAPHS_TO_DELETE, into which the names of the graphs to be deleted should be inserted, as follows:
use MYUSR; create procedure GRAPHS_TO_DELETE_SP (in gd_iris any) { declare gd_iri iri_id; declare dp, row any; result_names (gd_iri); dp := dpipe (0, '__I2IDN'); foreach (varchar iri in GD_IRIS) do { dpipe_input (dp, iri); } while (0 <> (row := dpipe_next (dp, 0))) { result (row[0]); } } ; drop view GRAPHS_TO_DELETE_VIEW; create procedure view GRAPHS_TO_DELETE_VIEW as MYUSR.DBA.GRAPHS_TO_DELETE_SP (gd_iris) (gd_iri any); create procedure DELETE_GRAPHS (in g_iris any) { declare g_iids any; if (not isvector (g_iris) and g_iris is not null) signal ('22023', '.....', 'The input argument must be an array of strings or null'); if (not length (g_iris)) return 0; delete from DB.DBA.RDF_QUAD where G in (select * from GRAPHS_TO_DELETE_VIEW where gd_iris = g_iris) option (loop exists); return row_count (); } ;
Finally call the procedure DELETE_GRAPHS to perform the deletion of the specified graphs. Note it does not return a result set and can be called as follows:
SQL> select MYUSR.DBA.DELETE_GRAPHS (vector ('g1', 'g2', 'g3'));
This will return the number of triples removed from the specified graphs.
Note: the procedure only applies to the cluster so to get IRI IDs via partitioned pipe (DAQ). It is not usable on single.
Use of SPARUL to add missing triples to a Named Graph. For example, an ontology/vocabulary extension.
A lot of ontologies and vocabularies started life prior to emergence of the Linked Data meme. As a result, many do not include rdfs:isDefinedBy relations (via triples) that associate Classes and Properties in an ontology with the ontology itself, using de-referencable URIs. The downside of this pattern is that Linked Data's follow-your-nose pattern isn't exploitable when viewing these ontologies e.g., when using contemporary Linked Data aware browsers.
If SPARUL privileges are assigned to SPARQL or other accounts associated with SPARQL Endpoint. Or via WebID? protected SPARQL endpoint with SPARUL is granted to SPARQL or specific accounts or WebIDs in a group.
INSERT INTO <LocalNamedGraphIRI> { ?s rdfs:DefinedBy <LocalOntologyEntityURI>. ?o rdfs:isDefinedBy <http://www.w3.org/ns/auth/acl>. } FROM <ExtSourceNamedGraphIRI> WHERE { ?s a ?o }
DEFINE get:soft "replace" SELECT DISTINCT * FROM <http://www.w3.org/ns/auth/acl#> WHERE { ?s ?p ?o }
INSERT INTO <http://www.w3.org/ns/auth/acl#> { ?s rdfs:DefinedBy <http://www.w3.org/ns/auth/acl>. ?o rdfs:DefinedBy <http://www.w3.org/ns/auth/acl>. } FROM <http://www.w3.org/ns/auth/acl#> WHERE { ?s a ?o }
SPARQL CLEAR GRAPH <http://www.w3.org/ns/auth/acl/> ; SPARQL CLEAR GRAPH <http://www.w3.org/ns/auth/acl> ; SPARQL CLEAR GRAPH <http://www.w3.org/ns/auth/acl#> ;
SPARQL LOAD <http://www.w3.org/ns/auth/acl> ;
SPARQL INSERT INTO <http://www.w3.org/ns/auth/acl> { ?s rdfs:DefinedBy <http://www.w3.org/ns/auth/acl>. ?o rdfs:DefinedBy <http://www.w3.org/ns/auth/acl>. } FROM <http://www.w3.org/ns/auth/acl> WHERE { ?s a ?o } ;
Assume a SPARQL query is to be executed against the Virtuoso DBpedia SPARQL endpoint (http://dbpedia.org/sparql) to retrieve the decimal longitude of the "NJ Devils' hometown" with cardinal direction, which determines whether the decimal is positive (in the case of East) or negative (in the case of West).
Virtuoso supports SPARQL-BI, an extended SPARQL 1.0 implementation from before SPARQL 1.1 was ratified, thus the "IF" operator is not currently supported, but an equivalent bif:either built-in SQL function does exist enabling an equivalent query to be executed:
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX dbo: <http://dbpedia.org/ontology/> PREFIX dbp: <http://dbpedia.org/property/> SELECT ?team ( (bif:either( ?ew = 'W', -1, 1)) * (?d + (((?m * 60) + ?s) / 3600.0)) as ?v) { ?team a dbo:HockeyTeam . ?team rdfs:label 'New Jersey Devils'@en . ?team dbp:city ?cityname . ?city rdfs:label ?cityname . ?city dbp:longd ?d; dbp:longm ?m; dbp:longs ?s; dbp:longew ?ew . }
![]() |
Figure: 1.5.38.1. SPARQL IF operator for SPARQL-BI endpoint |
In general, to control checkpoint in order to bypass client timeouts during long checkpoints when inserting triples into the Virtuoso server, one must disable automatic checkpoint by:
SQL> checkpoint_interval (0);
and also to make sure the AutoCheckpointLogSize is off. Then can be performed checkpoint whenever the client wants using the 'checkpoint' command.
However the need of cache check is not needed unless instance shows regular errors. By default the cache check is disabled.
Virtuoso offers a new option in the Virtuoso ini file to enable the check of page maps: PageMapCheck, 1/0 default 0:
-- Virtuoso.ini ... [Parameters] ... PageMapCheck = 0 ...
Also customer can add CheckpointSyncMode = 0 in order to disable sync during checkpoint to speed the operations.
The examples from below demonstrate how to incorporate Content Negotiation into RDF bulk loaders:
DB.DBA.RDF_LOAD_RDFXML (http_get ('http://purl.org/ontology/mo/', null, 'GET', 'Accept: application/rdf+xml', null, null, 3), 'http://purl.org/ontology/mo/', 'http://purl.org/ontology/mo/') .
DB.DBA.TTLP (http_get ('http://purl.org/ontology/mo/', null, 'GET', 'Accept: text/n3', null, null, 3), 'http://purl.org/ontology/mo/', 'http://purl.org/ontology/mo/'), '...', '...');
Injecting Linked Data into the Web has been a major pain point for those who seek personal, service, or organization-specific variants of DBpedia. Basically, the sequence goes something like this:
The problems typically take the following form:
To start addressing these problems, here is a simple guide for generating and publishing Linked Data using Virtuoso.
Existing RDF data can be added to the Virtuoso RDF Quad Store via a variety of built-in data loader utilities.
Many options allow you to easily and quickly generate RDF data from other data sources:
Install the Faceted Browser VAD package (fct_dav.vad) which delivers the following:
Three simple steps allow you, your enterprise, and your customers to consume and exploit your newly deployed Linked Data --
In Virtuoso it does not matter whether CREATE GRAPH and DROP GRAPH are called or not. Their purpose is to provide compatibility with the original SPARUL that was designed for Jena. Some Jena triple stores require explicit creation of each graph (like CREATE TABLE in SQL), they report errors if one tries to create a graph twice and so on.
For Virtuoso, a new graph is not an important system event, it has single quad store shared by all graphs. When a graph is made by CREATE GRAPH, its name is placed in an auxiliary table that is used solely to signal appropriate errors on CREATE graph that is CREATE-d already or on DROP of a missing graph; this table is not used in any way in SPARQL or other subsystems. In a perfect world, smart development tools will query that table to give hints to a programmer regarding available graphs, but the reality is not so perfect.
What's more important is a difference between DELETE FROM g { ?s ?p ?o } FROM g WHERE { ?s ?p ?o } and CLEAR GRAPH g, as both will delete all triples from the specified graph <g> with equal speed, but CLEAR GRAPH will also delete free-text index data about occurrences of literals in this specific graph. So CLEAR GRAPH will make the database slightly more compact and the text search slightly faster. (Naturally, DROP GRAPH makes CLEAR GRAPH inside, not just DELETE FROM ... )
What?
Creation of a stored procedure that enables users to find properties based on their string based token patterns.
Why?
When working with datasets from disparate datasources in a common named graph, there are times when you seek to scope sparql or spasql queries to specific property IRI/URI patterns without embarking upon inefficient regex heuristics.
What?
Make a stored procedure for querying against the main quad store table (rdf_quad). Surface the procedure as a magic predicate using "bif:" prefix. To find all the properties whose predicates start with "http://www.openlinksw.com/", a Virtuoso/PL procedure can be used as listed below:
SQL> create procedure PREDICATES_OF_IRI_PATH ( in path varchar, in dump_iri_ids integer := 0) { declare PRED_IRI varchar; declare PRED_IRI_ID IRI_ID; declare path_head_len integer; if (dump_iri_ids) result_names (PRED_IRI_ID); else result_names (PRED_IRI); for ( SELECT RP_NAME, RP_ID FROM RDF_PREFIX WHERE (RP_NAME >= path) AND (RP_NAME < path || chr(255)) ) do { declare fourbytes varchar; fourbytes := '----'; fourbytes[0] := bit_shift (RP_ID, -24); fourbytes[1] := bit_and (bit_shift (RP_ID, -16), 255); fourbytes[2] := bit_and (bit_shift (RP_ID, -8), 255); fourbytes[3] := bit_and (RP_ID, 255); for ( SELECT RI_NAME, RI_ID from RDF_IRI WHERE (RI_NAME >= fourbytes) AND (RI_NAME < fourbytes || chr(255)) ) do { if (exists (SELECT TOP 1 1 FROM RDF_QUAD WHERE P=RI_ID)) result (case when (dump_iri_ids) then RI_ID else RP_NAME || subseq (RI_NAME, 4) end); } } for ( path_head_len := length (path)-1; path_head_len >= 0; path_head_len := path_head_len - 1) { for ( SELECT RP_NAME, RP_ID from RDF_PREFIX WHERE RP_NAME = subseq (path, 0, path_head_len) ) do { declare fourbytes varchar; fourbytes := '----'; fourbytes[0] := bit_shift (RP_ID, -24); fourbytes[1] := bit_and (bit_shift (RP_ID, -16), 255); fourbytes[2] := bit_and (bit_shift (RP_ID, -8), 255); fourbytes[3] := bit_and (RP_ID, 255); for ( SELECT RI_NAME, RI_ID from RDF_IRI WHERE (RI_NAME >= fourbytes || subseq (path, path_head_len)) AND (RI_NAME < fourbytes || subseq (path, path_head_len) || chr(255)) ) do { if (exists (SELECT TOP 1 1 FROM RDF_QUAD WHERE P=RI_ID)) result (case when (dump_iri_ids) then RI_ID else RP_NAME || subseq (RI_NAME, 4) end); } } } } ; Done. -- 16 msec.
Example Usage
set echo on;
-- http://www.openlinksw.com/ SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/', 1); VARCHAR _______________________________________________________________________________ #i351 #i159 #i10 #i8 ... -- http://www.openlinksw.com/schemas/virtrdf SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/schemas/virtrdf', 1); PRED_IRI_ID VARCHAR _______________________________________________________________________________ #i159 #i10 #i8 #i6 #i160 #i269 #i278 #i275 -- http://www.openlinksw.com/schemas/virtrdf# SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/schemas/virtrdf#',1); PRED_IRI_ID VARCHAR _______________________________________________________________________________ #i159 #i10 #i8 #i6 #i160 #i269 #i278 ... -- http://www.openlinksw.com/schemas/virtrdf#i SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/schemas/virtrdf#i',1); PRED_IRI_ID VARCHAR _______________________________________________________________________________ #i159 #i10 #i8 -- other SQL>PREDICATES_OF_IRI_PATH ('no://such :)', 1); 0 Rows. -- 0 msec.
-- http://www.openlinksw.com/ SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/'); PRED_IRI VARCHAR _______________________________________________________________________________ http://www.openlinksw.com/schemas/DAV#ownerUser http://www.openlinksw.com/schemas/virtrdf#inheritFrom http://www.openlinksw.com/schemas/virtrdf#isSpecialPredicate http://www.openlinksw.com/schemas/virtrdf#item http://www.openlinksw.com/schemas/virtrdf#loadAs http://www.openlinksw.com/schemas/virtrdf#noInherit http://www.openlinksw.com/schemas/virtrdf#qmGraphMap http://www.openlinksw.com/schemas/virtrdf#qmMatchingFlags http://www.openlinksw.com/schemas/virtrdf#qmObjectMap http://www.openlinksw.com/schemas/virtrdf#qmPredicateMap http://www.openlinksw.com/schemas/virtrdf#qmSubjectMap ... -- http://www.openlinksw.com/schemas/virtrdf SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/schemas/virtrdf'); PRED_IRI VARCHAR _______________________________________________________________________________ http://www.openlinksw.com/schemas/virtrdf#inheritFrom http://www.openlinksw.com/schemas/virtrdf#isSpecialPredicate http://www.openlinksw.com/schemas/virtrdf#item http://www.openlinksw.com/schemas/virtrdf#loadAs http://www.openlinksw.com/schemas/virtrdf#noInherit http://www.openlinksw.com/schemas/virtrdf#qmGraphMap http://www.openlinksw.com/schemas/virtrdf#qmMatchingFlags http://www.openlinksw.com/schemas/virtrdf#qmObjectMap http://www.openlinksw.com/schemas/virtrdf#qmPredicateMap http://www.openlinksw.com/schemas/virtrdf#qmSubjectMap http://www.openlinksw.com/schemas/virtrdf#qmTableName ... -- http://www.openlinksw.com/schemas/virtrdf# SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/schemas/virtrdf#'); PRED_IRI VARCHAR _______________________________________________________________________________ http://www.openlinksw.com/schemas/virtrdf#inheritFrom http://www.openlinksw.com/schemas/virtrdf#isSpecialPredicate http://www.openlinksw.com/schemas/virtrdf#item http://www.openlinksw.com/schemas/virtrdf#loadAs http://www.openlinksw.com/schemas/virtrdf#noInherit http://www.openlinksw.com/schemas/virtrdf#qmGraphMap http://www.openlinksw.com/schemas/virtrdf#qmMatchingFlags http://www.openlinksw.com/schemas/virtrdf#qmObjectMap http://www.openlinksw.com/schemas/virtrdf#qmPredicateMap http://www.openlinksw.com/schemas/virtrdf#qmSubjectMap http://www.openlinksw.com/schemas/virtrdf#qmTableName http://www.openlinksw.com/schemas/virtrdf#qmf01blankOfShortTmpl http://www.openlinksw.com/schemas/virtrdf#qmf01uriOfShortTmpl http://www.openlinksw.com/schemas/virtrdf#qmfBoolOfShortTmpl http://www.openlinksw.com/schemas/virtrdf#qmfBoolTmpl ... -- http://www.openlinksw.com/schemas/virtrdf#i SQL>PREDICATES_OF_IRI_PATH ('http://www.openlinksw.com/schemas/virtrdf#i'); PRED_IRI VARCHAR _______________________________________________________________________________ http://www.openlinksw.com/schemas/virtrdf#inheritFrom http://www.openlinksw.com/schemas/virtrdf#isSpecialPredicate http://www.openlinksw.com/schemas/virtrdf#item 3 Rows. -- 15 msec. -- other SQL>PREDICATES_OF_IRI_PATH ('no://such :)'); PRED_IRI VARCHAR _______________________________________________________________________________ 0 Rows. -- 15 msec.
If you want to use the procedure's output inside SPARQL queries, it can be wrapped by a procedure view and it in turn can be used in an Linked Data View but it is redundant for most applications.
For typical "almost static" data, it is more practical to write a procedure that will store all found predicates in some dedicated "dictionary" graph and then use the graph as usual.
You can write an ordinary CONSTRUCT statement, ensure that it generates the triples intended to be added, and then replace the leading CONSTRUCT keyword with the INSERT INTO phrase.
Example:
CONSTRUCT { ?s <http://www.w3.org/2002/07/owl#equivalentClass> `iri (bif:replace(?o,'http://schema.rdfs.org/', 'http://schema.org/'))` } FROM <http://www.openlinksw.com/schemas/rdfs> WHERE { ?s <http://www.w3.org/2002/07/owl#equivalentClass> ?o };
SPARQL INSERT INTO <http://www.openlinksw.com/schemas/rdfs> { ?s <http://www.w3.org/2002/07/owl#equivalentClass> `iri (bif:replace(?o,'http://schema.rdfs.org/', 'http://schema.org/'))` } FROM <http://www.openlinksw.com/schemas/rdfs> WHERE { ?s <http://www.w3.org/2002/07/owl#equivalentClass> ?o } ;
The following example demonstrates how to remove graphs which are related to empty graphs:
PREFIX nrl:<http://www.semanticdesktop.org/ontologies/2007/08/15/nrl#> SELECT ( bif:exec(bif:sprintf("SPARQL CLEAR GRAPH<%s>", str(?mg)))) WHERE { ?mg nrl:coreGraphMetadataFor ?g . FILTER(?g in ( <urn:nepomuk:local:8a9e692a> )) . FILTER ( !bif:exists((SELECT (1) WHERE { GRAPH ?g { ?s ?p ?o . } . })) ) . }
Use of subqueries to enable literal values based joins.
Sophisticated access to literal values via subqueries provides powerful mechanism for enhancing sparql graph patterns via dynamic literal value generation.
Use select list variables from subqueries to produce literal object values in sparql graph patterns.
Assume in the following query, where should be used a sub-query to replace ?app:
SELECT DISTINCT ?r WHERE { graph ?g { ?r nie:url ?url . } . ?g nao:maintainedBy ?app . ?app nao:identifier "nepomukindexer" . }
If it is not sure that ?app is the only, for e.g., the triple ?app nao:identifier "nepomukindexer" can appear in more than one graph, then the query should be changed to:
SELECT DISTINCT ?r WHERE { graph ?g { ?r nie:url ?url . } . ?g nao:maintainedBy ?app . FILTER (?app = (SELECT ?a WHERE { ?a nao:identifier "nepomukindexer" })) }
or even shorter:
SELECT DISTINCT ?r WHERE { graph ?g { ?r nie:url ?url . } . ?g nao:maintainedBy `(SELECT ?a WHERE { ?a nao:identifier "nepomukindexer" })` . }
The way to prefer one label to the other can be done as follows:
create procedure lbl_order (in p any) { declare r int; r := vector ( 'http://www.w3.org/2000/01/rdf-schema#label', 'http://xmlns.com/foaf/0.1/name', 'http://purl.org/dc/elements/1.1/title', 'http://purl.org/dc/terms/title', 'http://xmlns.com/foaf/0.1/nick', 'http://usefulinc.com/ns/doap#name', 'http://rdf.data-vocabulary.org/name', 'http://www.w3.org/2002/12/cal/ical#summary', 'http://aims.fao.org/aos/geopolitical.owl#nameListEN', 'http://s.opencalais.com/1/pred/name', 'http://www.crunchbase.com/source_description', 'http://dbpedia.org/property/name', 'http://www.geonames.org/ontology#name', 'http://purl.org/ontology/bibo/shortTitle', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#value', 'http://xmlns.com/foaf/0.1/accountName', 'http://www.w3.org/2004/02/skos/core#prefLabel', 'http://rdf.freebase.com/ns/type.object.name', 'http://s.opencalais.com/1/pred/name', 'http://www.w3.org/2008/05/skos#prefLabel', 'http://www.w3.org/2002/12/cal/icaltzd#summary', 'http://rdf.data-vocabulary.org/name', 'http://rdf.freebase.com/ns/common.topic.alias', 'http://opengraphprotocol.org/schema/title', 'http://rdf.alchemyapi.com/rdf/v1/s/aapi-schema.rdf#Name', 'http://poolparty.punkt.at/demozone/ont#title' ); if (isiri_id (p)) p := id_to_iri (p); r := position (p, r); if (r = 0) return 100; return r; } ;
SPARQL DEFINE input:inference "facets" SELECT ?o WHERE { <http://uriburner.com/about/id/entity/http/www.linkedin.com/in/kidehen#CV_mfrTl4s6Jy> virtrdf:label ?o ; ?p ?o . } ORDER BY (sql:lbl_order (?p));
SELECT __ro2sq (O), lbl_order (P) FROM RDF_QUAD table option (with ''facets'') WHERE G = __i2id (?) AND S = __i2id (?) AND P = __i2id (''http://www.openlinksw.com/schemas/virtrdf#label'', 0) ORDER BY 2
To get object datatype should be used the internal Virtuoso/PL function DB.DBA.RDF_DATATYPE_OF_OBJ, visible in SPARQL as sql:RDF_DATATYPE_OF_OBJ.
Suppose the following scenario:
# Explicit typecast (insert) SQL> sparql insert into <test_datatype> { <a> <string> "string 1"^^xsd:string . }; callret-0 VARCHAR _______________________________________________________________________________ Insert into <test_datatype>, 1 (or less) triples -- done 1 Rows. -- 94 msec. #Not explicit typecast (insert) SQL> sparql insert into <test_datatype> { <a> <string> "string 2". }; callret-0 VARCHAR _______________________________________________________________________________ Insert into <test_datatype>, 1 (or less) triples -- done 1 Rows. -- 16 msec. SQL> SPARQL SELECT ?o (iri(sql:RDF_DATATYPE_OF_OBJ(?o, 'untyped!'))) FROM <test_datatype> { <a> <string> ?o} ; o callret-1 VARCHAR VARCHAR _______________________________________________________________________________ string 1 http://www.w3.org/2001/XMLSchema#string string 2 untyped! 2 Rows. -- 16 msec. SQL>
See more details here.
Virtuoso supports the following free-text options for bif:contains:
SQL>SPARQL SELECT ?s1 as ?c1, ?sc, ?rank WHERE { { { SELECT ?s1, (?sc * 3e-1) as ?sc, ?o1, (sql:rnk_scale (<LONG::IRI_RANK> (?s1))) as ?rank WHERE { ?s1 ?s1textp ?o1 . ?o1 bif:contains '"CNET"' option (score ?sc) . } ORDER BY DESC (?sc * 3e-1 + sql:rnk_scale (<LONG::IRI_RANK> (?s1))) LIMIT 20 OFFSET 0 } } }; c1 sc rank _________________________________________________________________________ http://www.mixx.com/stories/45003360/justi... 3 5.881291583872891e-14 http://www.mixx.com/stories/45099313/bing_... 2.7 5.881291583872891e-14 http://dbpedia.org/resource/CBS_Interactive 1.5 5.881291583872891e-14 http://dbpedia.org/resource/CBS_Interactive 1.5 5.881291583872891e-14 4 Rows. -- 1 msec.
SQL> SPARQL SELECT ?s ?sc WHERE { ?s ?p ?o . ?o bif:contains "tree" OPTION (score ?sc , score_limit 20) }; s sc VARCHAR INTEGER ________________________________________________________________________________ http://www.openlinksw.com/virtrdf-data-formats#default 24 http://www.openlinksw.com/virtrdf-data-formats#default 24 http://www.openlinksw.com/virtrdf-data-formats#sql-longvarbinary 21 http://www.openlinksw.com/virtrdf-data-formats#sql-varchar-dt 20 http://www.openlinksw.com/virtrdf-data-formats#sql-nvarchar-dt 20 http://www.openlinksw.com/virtrdf-data-formats#sql-varchar-lang 20 http://www.openlinksw.com/virtrdf-data-formats#sql-nvarchar-lang 20 7 Rows. -- 2 msec.
Virtuoso supports the following SPARQL Endpoint protection methods:
This section a sample scenario how to assign SPARQL ( for ex. SPARQL_SELECT ) role to Virtuoso SQL user:
![]() |
Figure: 1.5.52.1. Assign SPARQL Role to SQL User |
![]() |
Figure: 1.5.52.1. Assign SPARQL Role to SQL User |
![]() |
Figure: 1.5.52.1. Assign SPARQL Role to SQL User |
Previous
Virtuoso 6 FAQ |
Chapter Contents |
Next
Contents of Installation Guide |