W3C home > Mailing lists > Public > www-rdf-rules@w3.org > September 2002

RE: Query use cases

From: Seaborne, Andy <Andy_Seaborne@hplb.hpl.hp.com>
Date: Mon, 16 Sep 2002 17:08:10 +0100
Message-ID: <5E13A1874524D411A876006008CD059F04EBD96D@0-mail-1.hpl.hp.com>
To: "'RDF Rules'" <www-rdf-rules@w3.org>

Graham,

Personally, I don't like the idea of flattening the list in the query
results as the normal mode of operation - sometimes I do want the list as a
list, they aren't just a way of encoding a bag for multiple properties,
sometimes things like the order in the list matters or even the fact it is a
list at all.  I hoped the query system understood lists and treated them so
as to return a thing explicitly marked as list, not a plain resource - that
is just a convenience.

My approach for your example would be to write an application wrapper around
the query results that did the flattening to make it look like multiple
properties if the application so desired.  I see it as an application
modelling decision.

> Is that a request to submit an example?

Yes!

	Andy

-----Original Message-----
From: Graham Klyne [mailto:GK@NineByNine.org] 
Sent: 16 September 2002 16:35
To: Seaborne, Andy
Cc: Barnell, Alex; 'RDF Rules'
Subject: RE: Query use cases


At 12:57 PM 9/11/02 +0100, Seaborne, Andy wrote:
>That's an interesting example (daml:collection) - presumably it suggests
the
>query should return only the list head and start part way down (unlikely
the
>query would do this match but possible).  I didn't notice anything DQL
about
>this - maybe I missed it.

My take was that the query would return the contents of the list, not the 
list itself; e.g.

Thus a query against:

    head first item1 ;
         rest [ first item2 ;
                rest [ first item3 ;
                       rest nil ] ] .

might return matches against:

    item1
    item2
    item3

>The same is true of RDF alt/seq/bag - in many application situations it
>would be nicest to mask the RDF encoding of the compound structure and
>return a

Quite!

I thought that an implied rdf:member property might be used, so a QBE might
be:

     head rdf:member ?x .

to return item1, item2, item3 in the above example, or in:

     rdf:Seq rdf:_1 item1 .
     rdf:Seq rdf:_2 item2 .
     rdf:Seq rdf:_3 item3 .

>Alex Barnell has been doing some work here on "RDFObjects" which provides
>applications with a view of the RDF data as structured data items (e.g.
>action items for working groups, vCards or iCal entries).
>
>Is this way of thinking about it - as higher level data abstractions - what
>is going on, do you think?

Hmmm.... I'm not sure, but maybe yes.  In the sense that I want to treat a 
collection as an abstraction and query over it without being aware of its 
detailed encoding in RDF.

By the way, the actual use case here is for document issue tracking, with 
issue history represented as a daml:collection style of list.  I want to 
form a simple query that will return successive elements of the list in the 
same way that I can currently query a repeated property value (but in the 
collection case, the order in which bindings are returned matches the 
collection order).

>Would submit an example at
>http://rdfstore.sourceforge.net/2002/06/24/rdf-query/, run by Alberto
>Reggiori, which is a collection of query examples even if it's a use case
>with no solution.

Is that a request to submit an example?

#g


-------------------
Graham Klyne
<GK@NineByNine.org>
Received on Monday, 16 September 2002 12:08:25 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:53:09 GMT