On Mon, Oct 27, 2008 at 1:02 AM, heiho1 <[EMAIL PROTECTED]> wrote:
>
> Hello all,
>
> I've recently made the jump to running Django on Jython with an eye
> towards some mobile app projects which I've been discussing with
> various parties. One of the key features which I am looking into is
> the feasibility of supporting a pure RDF backend extension of Django's
> standard Model/Admin functionality. The idea here would be to
> integrate a solid RDF database as an alternate datastore for Django
> while still maintaining the automagic generation of admin interfaces.
> I have no real complaints at this moment about how Django handles
> object to relational mapping but I do believe that there are many
> situations where an RDF database simplifies domain object
> implementation and there are certainly semantic processing
> capabilities available via OWL and similar ontological processing APIs
> that I believe would make a natural extension to, for example,
> Django's built-in RSS feed capabilities.
>
> I'm currently taking a look at various RDF packages and Django
> integrations to evaluate this concept. I've looked at the following
> packages:
>
> RDFLib: http://rdflib.net/
> Django-RDF: http://code.google.com/p/django-rdf/
> Drake: https://jazz.net/open-services/samples/getting-started.jsp#detailed
>
> all of these follow the standard approach of implementing the RDF
> specification as a relational schema. This allows a straightforward
> integration with the existing RDBMS backends but it does not leverage
> the simplicity of pure RDF storage options like N-triples.
>
> My current thinking is to provide a binding layer between the Neo4J
> database [http://neo4j.org/] and Django with both running on jython.
>
> Has anyone on this list looked into RDF databases as backends in
> Django?
>
> From a preliminary review, it's looking like I would need to extend
> the models.Model and django.contrib.admin.Admin and then hook that
> code into the handlers. The signal API seems to be decoupled enough
> that it should not pose any problems implementing lifecycle events.
>
> Does anyone have any advice for me before I head off into the suburban
> parks of Django for an initial implementation? Any caveats I should
> consider which might make a pure RDF backend unfeasible?
I used OpenLink Virtuoso Triple Store (via their HTTP SPARQL binding)
with the python RDFLib library as a glue layer. For templating, I
devised a simple yet powerful Selector language, not as powerful as
Fresnel selectors though; in the background, the selectors were
"compiled" into more efficient SPARQL queries. This was implemented as
a filter and templatetags. I preferred to write the ontology in
something like Turtle format.
I did not integrate this with the admin or with the existing ORM.
However, I was able to get a good faceted browser going using mootools
in the frontend and a custom metadata layer. This allowed me to plugin
in any ontology (with little modification) and browse the triple store
with the faceted browser. Creating triples was also done as a
framework with some mootools code in the frontend, and in the backend,
a generic view.
Regards
Rajeev J Sebastian
--~--~-~--~~~---~--~~
You received this message because you are subscribed to the Google Groups
"Django developers" group.
To post to this group, send email to django-developers@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/django-developers?hl=en
-~--~~~~--~~--~--~---
