Index
General
RDF model API
Reasoner and inference models
- I want to develop my own rules, how do I get started?
- Why are there two different arrows ( -> and <- ) in the rule syntax?
Ontology API
- Why doesn't listClasses() (listProperties()/listIndividuals(), etc) work?
- Why doesn't the ontlogy API handle
sub-class(orsub-property,domain,range, etc) relationships in a DAML model? - Why does
.as( OntProperty.class )fail withConversionExceptionon SymmetricProperty (or other property types)?
Database and persistence
- Why do I get an exception when trying to create a new persistent model?
- Why do I run out of memory when trying to list statements in a persistent model?
- Has Jena2 persistence been ported to other database engines and platforms besides those officially supported?
- Is there a limit on the number of models in a database?
XML serialisation (reading and writing)
- no entries yet
RDQL and query processing
- no entries yet
Miscellaneous
- no entries yet
Answers
General
Q: Why do I get a ClassNotFoundException when I run Jena?
A: This means that one or more of the libraries that Jena depends on is not
on your classpath. Typically, all of the librarys (.jar files) in $JENA/lib,
where $JENA refers to the directory in which you installed Jena, should be on
your classpath. Consult the documentation for your JDK for details on setting
the classpath for your system.
RDF model API
Q. Why does the localname part of my URI look wrong?
A: In Jena it is possible to retrieve the localname part of a Resource or Property
URI. Sometimes developers create Resources with a full URI reference but
find that the result of a getLocalName call is not quite what they expected.
This is usually because the URI is ill-formed or cannot be correctly split
in the way you expected. The only reason for separating namespace and local
name is to support the XML serialization in which qnames are used for properties
and classes. Thus the main requirement of the split is that the localname
component must be a legal XML NCName. This means it must start with a letter
or _ character and can only contain limited punctuation. In particular,
they can't contain spaces, but then spaces are not legal in URI references
anyway. In general, it is best to not use the localname split to encode
any information, you should only be concerned with it if you are coding
a parser or writer.
Reasoner and inference models
Q. I want to develop my own rules, how do I get started?
A: The GenericRuleReasoner is the place to start. You can create instances of this reasoner by
supplying either an explict set of Rule objects or a configuration description (as a Jena Model)
that points to a local rule file. See the inference documentation for more details:
inference/index.html#rules
Q. Why are there two different arrows ( -> and <- ) in the rule syntax?
A: As explained in the documentation there are two rule systems available - a
forward chainer and a backward chainer. You can chose to use either or
use the two together in a hybrid mode.
So if we use Ti as short hand for triple patterns like (?x rdf:type ?C),
and if we ignore functors and procedural call out for now, then the syntax:
T1, T2, ... TN -> T0 .
means that if the triple patterns T1 to TN match in the data set then
then the triple T0 can be deduced as a consequence. Similarly
T0 <- T1, T2, ... TN .
means the same thing - the consequence is always on the "pointy" end of
the arrow.
Now if you are just using pure forward or backward rules then you could
chose to use either syntax interchangeably. This allows you to write a
rule set and use it in either mode. Though in practice "->" is the more
conventional direction in forward systems and "<-" is the more
conventional one in backward systems.
The hybrid configuration allows you to create new backward rules as a
result of forward rules firing so that the syntax:
T1, T2 -> [T0 <- T3, T4] .
Is saying that if both T1 and T2 match in the dataset then add the
backward rule "[T0 <- T3, T4]" after instantiating any bound variables.
Ontology API
Q: Why doesn't listClasses() (or listProperties()/listIndividuals(),
etc) work?
A: It does work. Extensive unit tests are used to check the correctness of Jena,
and are included in the downloaded source code for your reference. If listClasses(),
or a similar method, is not producing the answers you expect, or no answers
at all, you should first check that your model is correctly defined. Print a
copy of your model as a debug step, to see if the URI's match up (e.g, if you
are expecting resource x to be an individual of class Y, check that the rdf:type
of x is the same as the URI of the class declaration for Y). A common problem
is that relative URI's change depending where you read the model from. Try adding
an xml:base declaration to the document to ensure that URI's are
correctly specified.
Q: Why doesn't the ontlogy API handle sub-class
(or sub-property, domain, range, etc)
relationships in a DAML model?
A: These relationships are handled correctly, but the results you see are dependent on the
model configuration. The DAML specification includes a number of aliases for RDFS constructs to
copy them into the DAML+OIL namespace. This means that, for a DAML processor, daml:subClassOf
and rdfs:subClassOf are equivalent. This is declared by means of a
daml:samePropertyAs in the daml+oil.daml specification document. Without a reasoner
attached to the model, the ontology API will not recognise the equivalence with rdfs: properties.
Thus, if you are not seeing the expected results when processing a DAML ontology,
it is likely that your ontology file contains, for example,
<daml:Class rdf:ID="A"> <rdfs:subClassOf rdf:resource="B" /> ...
To fix this, either ensure that the ontology consistently uses daml: relationships,
or declare the ontology model with the DAML micro rule-reasoner:
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.DAML_MEM_RULE_INF, null );
Q: Why does .as( OntProperty.class ) fail with
ConversionException on SymmetricProperty (or other property types)?
A: This is a slightly tricky issue. Internally, .as() calls the supports check,
which tests whether the node that is being converted is a common flavour of property.
Strictly, the only necessary test should be 'has rdf:type rdf:Property',
because that is entailed by all of the other property types. However, that requires
the user to use a model with a reasoner, and some don't want to (for good reasons, e.g. building an editor).
The other position is to test for all the possible variants of property: object property,
datatype property, annotation, ontology, transitive, funcitonal, inverse functional, etc etc.
The problem with this is that it duplicates the work of the reasoner, and my expectation was that
most people would be running with a reasoner. Thus my code would be duplicating the functionality
of the reasoner, which is bad design. The compromise solution was to make the supports check test
for the common (top level) property types. Users who aren't using the reasoner,
can either test explicitly for the other property types they expect to encounter (e.g. SymmetricProperty),
or can turn off the supports check by setting
strict mode to false on the model.
Database and persistence
Q: Why do I get an exception when trying to create a new persistent model?
A: Assuming that your program uses correct methods to create the model (see
examples in the database howto), it may be that
your database files are corrupted. Jena2 does not do a good job in
checking the validity of the database. It makes a cursory check that some
required tables exist but does not check that the tables contain valid data. If
you suspect your database has been corrupted, you may invoke
cleanDB() on a DBConnection object
prior to creating your model. This removes all Jena2 tables from a database.
Warning: this removes any other existing Jena2 models from the database so make sure
that this is what you want to do.
Q: Why do I run out of memory when trying to list statements in a persistent
model?
A: Jena2 uses the JDBC interface for accessing databases. The JDBC
specification has no cursors. Consequently, when a query is processed by JDBC,
the entire result set is returned from the database at once and the application program then iterates
over the in-memory result set. If the result set is large, as is often the case
when listing all statements of a large model, it may exceed the heap size of
the Java virtual machine. If you suspect this is happening, you might try to
increase the heap size of the Java virtual machine (-vmargs
-Xmx500M for a 500 MB heap size). If this does not help, there is no
other work-around and the program should be recoded.
Q: Has Jena2 persistence been ported to other database engines and platforms
besides those officially supported?
A: The Jena team supports Jena2 persistence on the databases and operating
systems listed in the Database Interface Release
Notes.
Other users have had success porting Jena2 to other databases and platforms.
Jena2 has been ported to IBM's DB2 database. Contact
Liang-Jie Zhang for details. A port to
HSQLDB, a native-Java SQL database, has been done. Contact
Jan Danils for details. On the Mac OS X
platform, Jena2 has been successfully run using MySQL. Contact
Jim Nachlin for details. A Jena2
driver for Microsoft SQL Server has been written and tested with MsSQL 2000. The
source is available at
http://www.ur.se/jena/Jena2MsSql.zip. Contact
Erik Barke for more information.
Q: Is there a limit on
the number of models in a database?
A: The limit depends on the Jena database (schema) configuration and the
database engine (MySQL, PostgreSQL, Oracle, etc). Recall that a Jena model may
either be stored separately in its own database tables (the default) or,
alternatively, in tables that are shared with other models (see
StoreWithModel in the options for
persistent models). Also, a Jena model is identified internally by a 32 bit
integer. Consequently the maximum number of models is limited either by the
maximum number of tables allowed in a database (which depends on the database
engine) or by the maximum value of a 32 bit integer, i.e., 2G.
XML serialisation (reading and writing)
no entries yet
RDQL and query processing
no entries yet
Miscellaneous
no entries yet
