[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


From: James Michael DuPont
Subject: Re: [DotGNU]GNU.RDF
Date: Wed, 19 Mar 2003 13:49:38 -0800 (PST)

--- Peter Minten <address@hidden> wrote:
> James Michael DuPont wrote:
> > 
> > Looks good peter.
> > There are a couple of things that you might want to think about.
> > 
> > Isolation and abstraction.
> Could you explain that please?

It should be possible to isolate the structure of the tables from the
interface to them. A clean interface will make the layout of the tables
irrelvant. Also we should be able to plug in implementations from
various RDF database implementations into the framework.

In fact, I think that we can use alot of the good work done with
Redland, personally, I find that dave beckett has done a great job,
it is GPL compatible and industrial strength.

> > The design of Database Tables are going to have to abstracted a
> bit.
> > Maybe you will want to hold values, integers, uris in the tables.
> Here's a new attempt:
> TABLE triples
> {
>       subject: unsigned long; //refers to table strings
>       predicate: unsigned long; //refers to table strings
>       object: unsigned long; //refers to a data table
>       objecttype: char[1]; //tells what is the type of the object
>       //'s' = string, 'i' = integer
> }
> INDEX ON (subject) AND (subject AND predicate);
> TABLE strings
> {
>       pkey: unsigned long;
>       value: text;
> }
> Note that if object type is 'i' I use a little trick to improve
> efficiency: the
> first 32 bits of object are taken and placed into a signed integer
> using a
> simple bit copy. If I would place integers in a separate table that
> wouldn't
> make much sense since I would require 2 unsigned longs as foreign
> key/primary
> key while the actual value is only an integer.
> Also note that this model can be expanded for other data types. But
> this is the
> general setup.

OK, well yes and no.

First of all, you need three indexes: 
1. Subject and Predicate
2. Object and Predicate
3. Subject and Object

Second of all, I think you may want to use URIS as the primary keys and
avoid making the numeric ids. The database should be able to deal with
long keys, and that will make your database model simpler.

It should be possible to use a database model where each type of
subject has its own table. I want to look at the current research on
the RDFDBS before commenting further :
Storing RDF in a relational database
This page summarizes some current approaches to storing RDF in a
relational database. THIS IS A REQUEST FOR COMMENTS, so please do
contribute your ideas (address@hidden)! To goal is to come up
with the best way of storing RDF in a relational database, or identify
a set of solutions that are suitable for particular needs. 
What is rdfDB
rdfDB is intended to be a simple, scalable, open-source database for
RDF for systems like Semantic Web Services. 
The goals of this project are to build a database that is capable of 

* Supporting a graph oriented API via a textual query language ala SQL.

* Load/Reload an RDF file from a url into the database 
* Scalable to millions of nodes and triples. 
* Provide support for RDF Schemas. 
* Provide support for some basic forms of inferencing. 
* Provide both C and Perl access to the database. 
* The Perl philosophy applies : Simple things should be simple and
complex things should be possible.
SWAD-Europe: Scalability and Storage: Survey of Free Software / Open
Source RDF storage systems 
* Demonstrate storage of large-scale dynamic Semantic Web data 
* Develop storage system with optimised support for querying Semantic
Web data, schemas and provenance 
* Report on implementation issues for storing Semantic Web data
IMesh DB: A Model and Implementation of Information Discovery for the
IMesh Toolkit 
Author: Libby Miller 
This paper is about modelling, storing and querying complex metadata
about people and organisations. It describes the use of an ABC-like
metadata model to represent contextual information about the discovery
and creation of metadata. It also describes the use of the Squish query
language and Java implementation to store and query this metadata in
This is a quick writeup some work in progress, exploring various
inter-relationships between relational databases, tools from the logic
programming community, and W3C's RDF. We first discuss some broad
issues surrounding RDF APIs and query systems, before exploring a
number of more detailed case studies. Our first case study is based
around our SQL-ish ("Squish") interface to any RDF database that
exports either the Jena or Stanford RDF APIs. Our second case study
shows how tools from the logic programming community can be used to
export RDBMS systems to the Web.
Here is a good overview of Ont. Editors (I need to reviw this more)

> > I would like to try and help out on this.
> Great. What do you think of my new model?

I think I need to do more research and cite some of the existing
programs, and see what I can learn from thier mistakes. Then I can
comment more.

please keep up the good ideas,

James Michael DuPont

Do you Yahoo!?
Yahoo! Platinum - Watch CBS' NCAA March Madness, live on your desktop!

reply via email to

[Prev in Thread] Current Thread [Next in Thread]