You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@marmotta.apache.org by ss...@apache.org on 2013/02/26 10:24:33 UTC
svn commit: r1450094 - in /incubator/marmotta/site/trunk/content: ./
markdown/ markdown/kiwi/ markdown/ldcache/ markdown/ldclient/
markdown/ldpath/
Author: sschaffert
Date: Tue Feb 26 09:24:32 2013
New Revision: 1450094
URL: http://svn.apache.org/r1450094
Log:
updated website structure
Added:
incubator/marmotta/site/trunk/content/markdown/kiwi/
incubator/marmotta/site/trunk/content/markdown/kiwi/introduction.md.vm
incubator/marmotta/site/trunk/content/markdown/kiwi/reasoner.md.vm
incubator/marmotta/site/trunk/content/markdown/kiwi/transactions.md.vm
incubator/marmotta/site/trunk/content/markdown/kiwi/triplestore.md.vm
incubator/marmotta/site/trunk/content/markdown/kiwi/tripletable.md.vm
incubator/marmotta/site/trunk/content/markdown/kiwi/versioning.md.vm
incubator/marmotta/site/trunk/content/markdown/ldcache/
incubator/marmotta/site/trunk/content/markdown/ldcache/introduction.md.vm
incubator/marmotta/site/trunk/content/markdown/ldclient/
incubator/marmotta/site/trunk/content/markdown/ldclient/introduction.md.vm
incubator/marmotta/site/trunk/content/markdown/ldpath/
incubator/marmotta/site/trunk/content/markdown/ldpath/backends.md.vm
incubator/marmotta/site/trunk/content/markdown/ldpath/introduction.md.vm
incubator/marmotta/site/trunk/content/markdown/ldpath/language.md.vm
incubator/marmotta/site/trunk/content/markdown/ldpath/usage.md.vm
Removed:
incubator/marmotta/site/trunk/content/markdown/ldcache.md
incubator/marmotta/site/trunk/content/markdown/ldclient.md
Modified:
incubator/marmotta/site/trunk/content/markdown/kiwi-triplestore.md.vm
incubator/marmotta/site/trunk/content/site.xml
Modified: incubator/marmotta/site/trunk/content/markdown/kiwi-triplestore.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi-triplestore.md.vm?rev=1450094&r1=1450093&r2=1450094&view=diff
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi-triplestore.md.vm (original)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi-triplestore.md.vm Tue Feb 26 09:24:32 2013
@@ -94,6 +94,7 @@ We plan to add support for additional da
Additionally, there are some things to keep in mind when using a KiWi triple store (all of them are good coding
practice, but in KiWi they also have performance implications):
+* if you are interested in good performance (production environments), use a proper database (e.g. *PostgreSQL*)!
* a RepositoryConnection has a direct correspondence to a database connection, so it always needs to be closed properly;
if you forget closing connections, you will have resource leakage pretty quickly
* all operations carried out on a repository connection are directly carried out in the database (e.g. inserting
Added: incubator/marmotta/site/trunk/content/markdown/kiwi/introduction.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi/introduction.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi/introduction.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi/introduction.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,20 @@
+# KiWi Triple Store #
+
+The KiWi triple store is a high performance transactional triple store backend for OpenRDF Sesame building on top of a
+relational database (currently H2, PostgreSQL, or MySQL). It has optional support for rule-based reasoning (sKWRL) and
+versioning of updates. The KiWi triple store is also the default backend for Apache Marmotta. It originated in the
+EU-funded research project "KiWi - Knowledge in a Wiki" (hence the name).
+
+The KiWi triple store is composed of a number of Sesame Sail modules that can be combined and stacked as needed.
+Currently (Apache Marmotta v3.0), the KiWi triple store offers the following modules:
+
+* kiwi-triplestore: implements triple persistence in a relational database
+* kiwi-transactions: adds extended transaction support to a notifying sail (notifies on transaction commit)
+* kiwi-tripletable: support for in-memory indexed Java Collections for OpenRDF statements
+* kiwi-contextaware: support for context-aware OpenRDF Sails (allow overriding contexts in statements)
+* kiwi-reasoner: adds a rule-based forward chaining reasoner with truth maintenance for the KiWi triple store
+* kiwi-versioning: adds versioning of updates to a KiWi triple store
+
+Versioning and Reasoner only work with a KiWi store as parent Sail, i.e. they cannot be used with other Sesame backends.
+Transactions, Context-Aware Sails, and the Triple Table support classes are in principle independent and can also
+be stacked with other storage backends.
Added: incubator/marmotta/site/trunk/content/markdown/kiwi/reasoner.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi/reasoner.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi/reasoner.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi/reasoner.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,98 @@
+# KiWi Reasoner #
+
+The KiWi reasoner is a powerful and flexible rule-based reasoner that can be used on top of a KiWi Triple Store. Its
+expressivity is more or less the same as Datalog, i.e. it will always terminate and can be evaluated in polynomial
+time (data complexity not taking into account the number of rules). In the context of triple stores, the KiWi
+reasoner can be used to easily implement the implicit semantics of different domain vocabularies. For example, the
+following rule program expresses SKOS semantics:
+
+ @prefix skos: <http://www.w3.org/2004/02/skos/core#>
+
+ ($1 skos:broader $2) -> ($1 skos:broaderTransitive $2)
+ ($1 skos:narrower $2) -> ($1 skos:narrowerTransitive $2)
+
+ ($1 skos:broaderTransitive $2), ($2 skos:broaderTransitive $3) -> ($1 skos:broaderTransitive $3)
+ ($1 skos:narrowerTransitive $2), ($2 skos:narrowerTransitive $3) -> ($1 skos:narrowerTransitive $3)
+
+ ($1 skos:broader $2) -> ($2 skos:narrower $1)
+ ($1 skos:narrower $2) -> ($2 skos:broader $1)
+
+ ($1 skos:broader $2) -> ($1 skos:related $2)
+ ($1 skos:narrower $2) -> ($1 skos:related $2)
+ ($1 skos:related $2) -> ($2 skos:related $1)
+
+Similarly, the reasoner can be used for expressing RDFS subclass and domain inference, as well as a subset of OWL
+semantics (the one that is most interesting :-P ). Beyond RDFS and OWL, it also allows implementing domain-specific
+rule semantics. Additional examples for programs can be found in the source code.
+
+The reasoner is implemented as a incremental forward-chaining reasoner with truth maintenance. In practice, this
+means that:
+
+* incremental reasoning is triggered after a transaction commits successfully; the reasoner will then apply those
+ rules that match with at least one of the newly added triples
+* inferred triples are then materialized in the triple store in the inferred context (see the configuration of
+ the triple store above) and are thus available in the same way as base triples
+* truth maintenance keeps track of the reasons (i.e. rules and triples) why an inferred triple exists; this helps
+ making updates (especially removals of rules and triples) very efficient without requiring to completely
+ recompute all inferred triples
+
+Maven Artifact
+--------------
+
+The KiWi Reasoner can only be used in conjunction with the KiWi Triple Store, because it maintains most of its
+information in the relational database (e.g. the data structures for truth maintenance) and directly translates
+rule body query patterns into SQL. To include it in a project that uses the KiWi Triple Store, add the following
+dependency to your Maven project:
+
+ <dependency>
+ <groupId>org.apache.marmotta</groupId>
+ <artifactId>kiwi-reasoner</artifactId>
+ <version>${projectVersion}</version>
+ </dependency>
+
+
+Code Usage
+----------
+
+The KiWi Reasoner can be stacked into any sail stack with a transactional sail (see kiwi-transactions) and a
+KiWi Store at its root. The relevant database tables are created automatically when the repository is initialised.
+A simple repository with reasoner is initialized as follows:
+
+ KiWistore = new KiWiStore("test",jdbcUrl,jdbcUser,jdbcPass,dialect, "http://localhost/context/default", "http://localhost/context/inferred");
+ KiWiTransactionalSail tsail = new KiWiTransactionalSail(store);
+ KiWiReasoningSail rsail = new KiWiReasoningSail(tsail, new ReasoningConfiguration());
+ repository = new SailRepository(rsail);
+ repository.initialize();
+
+ // add a reasoning program
+ rsail.addProgram("simple", this.getClass().getResourceAsStream("simple.kwrl"));
+
+ // update an existing reasoning program
+ rsail.updateProgram("simple", ...);
+
+ // run full reasoning (delete all existing inferred triples and re-create them)
+ rsail.reRunPrograms();
+
+The reasoner can have any number of reasoning programs. The concept of a program is merely introduced to group
+different tasks. Internally, all reasoning rules are considered as an unordered collection, regardless which
+program they belong to.
+
+Performance Considerations
+--------------------------
+
+Even though the reasoner is efficient compared with many other reasoners, there are a number of things to take into
+account, because reasoning is always a potentially expensive operation:
+
+* reasoning will always terminate, but the upper bound for inferred triples is in theory the set of all combinations
+ of nodes occurring in base triples in the database used as subject, predicate, or object, i.e. n^3
+* specific query patterns with many ground values are more efficient than patterns with many variables, as fixed
+ values can considerably reduce the candidate results in the SQL queries while variables are translated into SQL
+ joins
+* re-running a full reasoning can be extremely costly on large databases, so it is better configuring the reasoning
+ programs before importing large datasets (large being in the range of millions of triples)
+* updating a program is more efficient than first deleting the old version and then adding the new version,
+ because the reasoner compares old and new program and only updates the changed rules
+
+In addition, the reasoner is currently executed in a single worker thread. The main reason is that otherwise there
+are potentially many transaction conflicts. We are working on an improved version that could benefit more from
+multi-core processors.
Added: incubator/marmotta/site/trunk/content/markdown/kiwi/transactions.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi/transactions.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi/transactions.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi/transactions.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,44 @@
+# KiWi Transaction Support #
+
+
+OpenRDF Sesame already offers basic transaction handling and update notification support in any OpenRDF sail stack around
+a NotifyingSail. This module builds on this functionality to provide a mechanism for keeping track of all changes
+(added and removed triples) occurring between the time a transaction began and the time the transaction was committed
+or rolled back. The transaction data is then handed over to all registered transaction listeners at certain event points
+(in analogy to JPA we offer "before commit", "after commit", "on rollback"). Since the KiWi transaction support builds
+upon the NotifyingSail, it can be used in any OpenRDF sail stack, independently of the other KiWi modules.
+
+Extended transaction support is e.g. used by the versioning component (each transaction is considered a unit of work or
+version) and by the reasoner (on transaction commit, the transaction data is handed to the incremental reasoner). It
+is also used by some extended Apache Marmotta and Linked Media Framework functionalities like the LMF Semantic Search.
+
+Maven Artifact
+--------------
+
+To use the extended transaction support, include the following artifact in your Maven build file:
+
+ <dependency>
+ <groupId>org.apache.marmotta</groupId>
+ <artifactId>kiwi-transactions</artifactId>
+ <version>${projectVersion}</version>
+ </dependency>
+
+Code Usage
+----------
+
+In your code, the KiWi extended transactions can easily be stacked into your sail stack around any NotifyingSail.
+Event listeners can be added/removed by calling the appropriate addTransactionListener and removeTransactionListener
+methods:
+
+ KiWiTransactionalSail sail = new KiWiTransactionalSail(new MemoryStore());
+ sail.addTransactionListener(...);
+ Repository repository = new SailRepository(sail);
+ ...
+
+The TransactionListener interface defines three methods:
+
+* _beforeCommit(TransactionData data)_ is called just before the transaction actually carries out its commit
+ to the database;
+* _afterCommit(TransactionData data)_ is called immediately after the transaction has been committed to the database
+ (i.e. you can rely on the data being persistent)
+* _rollback(TransactionData data)_ is called when the transaction is rolled back (e.g. in case of an error)
Added: incubator/marmotta/site/trunk/content/markdown/kiwi/triplestore.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi/triplestore.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi/triplestore.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi/triplestore.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,92 @@
+# KiWi Store #
+
+
+The heart of the KiWi triple store is the KiWiStore storage backend. It implements a OpenRDF Notifying Sail on top
+of a custom relational database schema. It can be used in a similar way to the already existing (but now deprecated)
+OpenRDF RDBMS backends. The KiWi triple store operates almost directly on top of the relational database, there is
+only minimal overhead on the Java side (some caching and result transformations). Each OpenRDF repository connection
+is a database connection, and each repository result is a database cursor (so it supports lazy fetching when iterating
+over the result).
+
+Maven Artifact
+--------------
+
+To use the KiWiStore, include the following artifact in your Maven build file:
+
+ <dependency>
+ <groupId>org.apache.marmotta</groupId>
+ <artifactId>kiwi-triplestore</artifactId>
+ <version>${projectVersion}</version>
+ </dependency>
+
+Code Usage
+----------
+
+In your code, creating a KiWi triple store works mostly like other OpenRDF backends. The only additional data that is
+required are the JDBC connection details for accessing the database (i.e. database type, database URI, database user
+and database password) and how to store inferred triples or triples without explicit context. You can create a new
+instance of a KiWi store as follows:
+
+ String defaultContext = "http://localhost/context/default";
+ String inferredContext = "http://localhost/context/inferred";
+ KiWiDialect dialect = new H2Dialect();
+ KiWiStore store = new KiWiStore("test",jdbcUrl,jdbcUser,jdbcPass,dialect, defaultContext, inferredContext );
+ Repository repository = new SailRepository(store);
+ try {
+ repository.initialize();
+
+ // get a connection and perform operations as usual
+ RepositoryConnection con = repository.getConnection();
+ try {
+ con.begin();
+
+ // do stuff
+
+ con.commit();
+ } finally {
+ con.close();
+ }
+ } catch(RepositoryException ex) {
+ // handle exception
+ } finally {
+ repository.shutdown();
+ }
+
+Note that there are some "uncommon" parameters, most notably the defaultContext and inferredContext:
+
+* **defaultContext** is the URI of the context to use in case no explicit context is specified; this changes the default
+ behaviour of OpenRDF a bit, but it is the cleaner approach (and more efficient in the relational database because it
+ avoids NULL values)
+* **inferredContext** is the URI to use for storing all triples that are inferred by some reasoner (either the KiWi reasoner
+ or the OpenRDF RDFS reasoner); this is also a different behaviour to OpenRDF; we use it because the semantics is
+ otherwise not completely clear in case an inference was made based on the information stemming from two different
+ contexts
+* **dialect** specifies the dialect to use for connecting to the database; currently supported dialects are H2Dialect,
+ PostgreSQLDialect and MySQLDialect; note that the MySQL JDBC library is licensed under LGPL and can therefore not
+ be shipped with Apache Marmotta
+
+We plan to add support for additional databases over time.
+
+Performance Considerations
+--------------------------
+
+Additionally, there are some things to keep in mind when using a KiWi triple store (all of them are good coding
+practice, but in KiWi they also have performance implications):
+
+* if you are interested in good performance (production environments), use a proper database (e.g. *PostgreSQL*)!
+* a RepositoryConnection has a direct correspondence to a database connection, so it always needs to be closed properly;
+ if you forget closing connections, you will have resource leakage pretty quickly
+* all operations carried out on a repository connection are directly carried out in the database (e.g. inserting
+ triples); the database connection is transactional, i.e. changes will only be available to other transactions when
+ the commit() method is called explicitly; it is therefore good practice to always commit or rollback a connection
+ before closing it
+* a RepositoryResult has a direct correspondence to a database ResultSet and therefore to a database cursor, so like
+ with connections, it needs to be closed properly or otherwise you will have resource leakage
+* the value factory of the KiWi Store maintains its own, separate database connection for creating and retrieving
+ RDF values; any newly created values are committed immediately to the database to make sure they are available to
+ other transactions
+* the database tables will only be created when repository.initialize() is called; if the tables already exist,
+ initialization will check whether a schema upgrade is required and automatically do the upgrade if needed
+* the repository must be explicitly shutdown when it is no longer needed, or otherwise it will keep open
+ the database connection of the value factory as well as the internal connection pool
+
Added: incubator/marmotta/site/trunk/content/markdown/kiwi/tripletable.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi/tripletable.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi/tripletable.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi/tripletable.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,44 @@
+# KiWi Triple Table #
+
+The KiWi Triple Table offers efficient Java Collections over OpenRDF Statements. It implements the Java Set interface,
+but offers query support (listing triples with wildcards) with in-memory SPOC and CSPO indexes. This is useful if you
+want to keep large temporary in-memory collections of triples and is e.g. used by the kiwi-transactions module for
+keeping track of added and removed triples in the transaction data. It can also be used for caching purposes.
+
+Maven Artifact
+--------------
+
+The KiWi Triple Table can be used with any OpenRDF repository, it is merely a container for triples. To use the library
+in your own project, add the following Maven dependency to your project:
+
+ <dependency>
+ <groupId>org.apache.marmotta</groupId>
+ <artifactId>kiwi-tripletable</artifactId>
+ <version>${projectVersion}</version>
+ </dependency>
+
+Code Usage
+----------
+
+As the triple table implements the Set interface, usage is very simple. The following code block illustrates how:
+
+ TripleTable<Statement> triples = new TripleTable<Statement>();
+
+ // add some triples
+ triples.add(valueFactory.createStatement(s1,p1,o1);
+ triples.add(valueFactory.createStatement(s2,p2,o2);
+ ...
+
+ // iterate over all triples
+ for(Statement t : triples) {
+ // do something with t
+ }
+
+ // list only triples with subject s1
+ for(Statement t : triples.listTriples(s1,null,null,null)) {
+ // do something with t
+ }
+
+Note that the KiWi Triple Table does not implement a complete repository and therefore neither offers its own value
+factory nor allows persistence of statements or connection management. In case you need an in-memory repository with
+support for all these features, consider using a OpenRDF memory sail.
Added: incubator/marmotta/site/trunk/content/markdown/kiwi/versioning.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/kiwi/versioning.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/kiwi/versioning.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/kiwi/versioning.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,89 @@
+# KiWi Versioning #
+
+The KiWi Versioning module allows logging of updates to the triple store as well as accessing snapshots of the
+triple store at any given time in history. In many ways, it is similar to the history functionality offered by
+Wiki systems. KiWi Versioning can be useful for many purposes:
+
+* for tracking changes to resources and the whole repository and identifying the source (provenance) of certain
+ triples
+* for creating snapshots of the repository that are "known to be good" and referring to these snapshots later
+ while still updating the repository with new data
+* for more easily reverting errorneous changes to the triple store, in a similar way to a wiki; this can e.g. be
+ used in a "data wiki"
+
+Currently, the KiWi Versioning module allows tracking changes and creating snapshots. Reverting changes has not
+yet been implemented and will be added later (together with support for pruning old versions).
+
+Versioning is tightly bound to the transaction support: a version is more or less the transaction data after
+commit time. This corresponds to the concept of "unit of work": a unit of work is finished when the user
+explicitly commits the transaction (e.g. when the entity has been completely added with all its triples or
+the ontology has been completely imported).
+
+Maven Artifact
+--------------
+
+The KiWi Versioning module can only be used in conjunction with the KiWi Triple Store, because it maintains most of
+its information in the relational database (e.g. the data structures for change tracking). To include it in a
+project that uses the KiWi Triple Store, add the following dependency to your Maven project:
+
+ <dependency>
+ <groupId>org.apache.marmotta</groupId>
+ <artifactId>kiwi-versioning</artifactId>
+ <version>${projectVersion}</version>
+ </dependency>
+
+Code Usage
+----------
+
+You can use the KiWi Versioning module in your own code in a sail stack with a KiWi transactional sail and a KiWi
+Store at the root. The basic usage is as follows:
+
+ KiWiStore store = new KiWiStore("test",jdbcUrl,jdbcUser,jdbcPass,dialect, "http://localhost/context/default", "http://localhost/context/inferred");
+ KiWiTransactionalSail tsail = new KiWiTransactionalSail(store);
+ KiWiVersioningSail vsail = new KiWiVersioningSail(tsail);
+ repository = new SailRepository(vsail);
+ repository.initialize();
+
+ // do something with the repository (e.g. add data)
+ ...
+
+ // list all versions (note that there are many methods with different parameters, including a subject resource,
+ // a date range, or both)
+ RepositoryResult<Version> versions = vsail.listVersions();
+ try {
+ while(versions.hasNext()) {
+ Version v = version.next();
+
+ // do something with v
+ }
+ } finally {
+ versions.close();
+ }
+
+ // get a snapshot connection for a certain date
+ Date snapshotDate = new Date(...);
+ RepositoryConnection snapshotConnection = vsail.getSnapshot(snapshotDate);
+ try {
+ // access the triples in the snapshot as they were at the time of the snapshot
+ ...
+ } finally {
+ snapshotConnection.close();
+ }
+
+Note that for obvious reasons (you cannot change history!), a snapshot connection is read-only. Accessing any update
+functionality of the connection will throw a RepositoryException. However, you can of course even run SPARQL queries
+over a snapshot connection (SPARQLing the past...).
+
+
+Performance Considerations
+--------------------------
+
+When versioning is enabled, bear in mind that nothing is ever really deleted in the triple store. Triples that are
+removed in one of the updates are simply marked as "deleted" and added to the version information
+for removed triples.
+
+Otherwise there is no considerable performance impact. Accessing snapshots at any date is essentially as efficient
+as any ordinary triple access (but it does not do triple caching).
+
+
+
Added: incubator/marmotta/site/trunk/content/markdown/ldcache/introduction.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/ldcache/introduction.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/ldcache/introduction.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/ldcache/introduction.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,2 @@
+# Linked Data Caching #
+
Added: incubator/marmotta/site/trunk/content/markdown/ldclient/introduction.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/ldclient/introduction.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/ldclient/introduction.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/ldclient/introduction.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,2 @@
+# Linked Data Client #
+
Added: incubator/marmotta/site/trunk/content/markdown/ldpath/backends.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/ldpath/backends.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/ldpath/backends.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/ldpath/backends.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1 @@
+# LDPath Backends #
\ No newline at end of file
Added: incubator/marmotta/site/trunk/content/markdown/ldpath/introduction.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/ldpath/introduction.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/ldpath/introduction.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/ldpath/introduction.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,63 @@
+# LDPath Query Language #
+
+LDPath is a simple path-based query language, similar to XPath or SPARQL Property
+Paths, that is particularly well-suited for querying and retrieving resources
+from the Linked Data Cloud by following RDF links between resources and servers.
+
+For example, the following path query would select the names of all friends of the context resource:
+
+ foaf:knows / foaf:name :: xsd:string
+
+## Introduction
+
+LDPath library is a collection of generic libraries that are independent of the
+underlying RDF implementation. Currently, there are backends for sesame, for RDF
+files, and for Linked Data. You can easily implement your own backends by implementing
+a straightforward interface (RDFBackend).
+
+LDPath can serve many different purposes. It can e.g. serve as
+
+* a simple query language for selecting nodes or values in your own triple store programmatically from Java
+* a query language for transparently querying resources in the Linked Data Cloud and following links between datasets
+* a foundation for templating languages to render results based on RDF or Linked Data
+* a foundation for building a semantic search index (used e.g. in the Linked Media Framework and in Apache Stanbol)
+* a query language for experimenting with the Linked Data Cloud
+
+## Modules
+
+The LDPath project consists of a collection of modules that can be combined as needed. We have grouped the modules in
+core modules, backends, and extensions. Modules are available in our Maven repository, see MavenArtifacts.
+
+@@TODO@@: this needs to be updated
+
+### Core Modules
+
+The following modules are the core modules of LDPath and are needed in every situation:
+
+* ldpath-api: contains interfaces used by the language; needed for custom extensions
+* ldpath-core: contains the core, backend-independent implementation of the LDPath language, including parser and
+evaluator; expects some backend implementation to be present.
+
+### Backend Modules
+
+We provide a number of backends that are ready-to-use in your own projects. Implementing
+a backend is usually straightforward and involves mainly implementing the RDFBackend
+interface. RDFBackend makes use of Java Generics , so you are able to always use the
+data model of your backend directly. The following backends are provided by the
+distribution:
+
+* ldpath-backend-sesame: a generic backend implementation for Sesame repositories. A Sesame repository can be passed over on initialisation
+* ldpath-backend-jena: a generic backend implementation for Jena models. A Jena model can be passed over on initialisation
+* ldpath-backend-file: a file-based backend implementation allowing you to query the contents of an RDF file
+* ldpath-backend-linkeddata: a sophisticated backend implementation that queries and caches resources on the Linked Data Cloud
+
+### Extension Modules
+
+Based on LDPath, we have implemented a number of extension modules. Some are part
+of other projects like the Linked Media Framework or Apache Stanbol. Part of the
+LDPath project itself are currently the following modules:
+
+* ldpath-template: implements an extension of the FreeMarker template engine that allows constructing templates with
+ LDPath statements for inserting and iterating over values (example template); this module is backend-independent
+* ldpath-template-linkeddata: a backend implementation for ldpath-template that allows querying over the Linked Data
+ Cloud; provides only a command-line tool for processing templates
Added: incubator/marmotta/site/trunk/content/markdown/ldpath/language.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/ldpath/language.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/ldpath/language.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/ldpath/language.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,2 @@
+# LDPath Language Reference #
+
Added: incubator/marmotta/site/trunk/content/markdown/ldpath/usage.md.vm
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/markdown/ldpath/usage.md.vm?rev=1450094&view=auto
==============================================================================
--- incubator/marmotta/site/trunk/content/markdown/ldpath/usage.md.vm (added)
+++ incubator/marmotta/site/trunk/content/markdown/ldpath/usage.md.vm Tue Feb 26 09:24:32 2013
@@ -0,0 +1,11 @@
+# LDPath Usage #
+
+The library is provided as Maven artifact, you you would need to declare a
+dependency like:
+
+ <dependency>
+ <groupId>org.apache.marmotta</groupId>
+ <artifactId>marmotta-ldpath</artifactId>
+ <version>${projectVersion}</version>
+ </dependency>
+
Modified: incubator/marmotta/site/trunk/content/site.xml
URL: http://svn.apache.org/viewvc/incubator/marmotta/site/trunk/content/site.xml?rev=1450094&r1=1450093&r2=1450094&view=diff
==============================================================================
--- incubator/marmotta/site/trunk/content/site.xml (original)
+++ incubator/marmotta/site/trunk/content/site.xml Tue Feb 26 09:24:32 2013
@@ -28,7 +28,9 @@
<fluidoSkin>
<topBarEnabled>true</topBarEnabled>s
<sideBarEnabled>false</sideBarEnabled>
+<!--
<googleSearch />
+-->
<!--
<twitter>
<user>ApacheMarmotta</user>
@@ -65,15 +67,31 @@
<item name="Privacy" href="privacy.html" />
</menu>
<!--<menu ref="parent" inherit="bottom" />-->
- <menu name="Project" ref="reports" inherit="top" />
+ <menu name="KiWi Triple Store">
+ <item name="Introduction" href="kiwi/introduction.html"/>
+ <item name="Store" href="kiwi/triplestore.html"/>
+ <item name="Transactions" href="kiwi/transactions.html"/>
+ <item name="Triple Table" href="kiwi/tripletable.html"/>
+ <item name="Reasoner" href="kiwi/reasoner.html" />
+ <item name="Versioning" href="kiwi/versioning.html"/>
+ </menu>
+ <menu name="LDClient">
+ <item name="Introduction" href="ldclient/introduction.html"/>
+ </menu>
+ <menu name="LDCache">
+ <item name="Introduction" href="ldcache/introduction.html"/>
+ </menu>
+ <menu name="LDPath">
+ <item name="Introduction" href="ldpath/introduction.html"/>
+ <item name="Language" href="ldpath/language.html"/>
+ <item name="Usage" href="ldpath/usage.html"/>
+ <item name="Backends" href="ldpath/backends.html"/>
+ </menu>
<menu name="Libraries">
<item name="Client Library" href="client-library.html" />
- <item name="KiWi Triple Store" href="kiwi-triplestore.html" />
- <item name="LDCache" href="ldcache.html" />
- <item name="LDClient" href="ldclient.html" />
- <item name="LDPath" href="ldpath.html" />
<item name="Sesame Tools" href="sesame.html" />
- </menu>
+ </menu>
+ <menu name="Reports" ref="reports" inherit="top" />
<menu name="The ASF">
<item name="The Apache Software Foundation" href="http://www.apache.org" />
<item name="Apache Incubator" href="http://incubator.apache.org" />