- From: Alexandre Bertails <bertails@w3.org>
- Date: Thu, 17 Feb 2011 14:53:59 -0500 (EST)
- To: "Juan Sequeda" <juanfederico@gmail.com>
- Cc: "Alexandre Bertails" <bertails@w3.org>, public-rdb2rdf-wg@w3.org
>>
>>
>>
>> [1] is a clear improvement of the RDF semantics, using proper maths
>> (denotational semantics). If you're not familiar with it, I suggest
>> you read [4]. I'm not claiming this is the final version and I already
>> know what I want to improve.
>>
>
> aha moment! Reading [4], I now understand where you are coming from and
> your
> motivation. I'm not a programming languages guy and from the small amount
> of
> what I have read about denotational semantics, is that it's a way to
> formalize the meaning of a programming language. However, the direct
> mapping
> is a mapping and not a programming language.
It's right we do use that a lot to specify the semantics of a programming
languages. Indeed, it's not restricted to those.
> So this has always been my
> confusion of why do it this way. Now reading that in [4], they used
> denotational semantics to describe the formal semantics of XSLT, a way to
> translate (map) from one XML doc to another XML doc, I understand where
> you
> are coming from.
When you define a "denotational semantics for X in Y", it means you're
denoting objects from the X domain into the Y domain. People usually
shorten that by saying "a Y semantics for X". That's why the Direct
Mapping is *not* a set semantics (and I'll keep correcting people saying
that) but an RDF semantics.
We do use set notations [5] for *defining* the functions. We also use the
Set (as well as MultiSet and List) abstract data type [6] for defining the
RDB and RDF data models.
Also, I'm fine when you say you're working on the Datalog semantics when
you're mapping RDB into Datalog, both domains being perfectly defined.
> If only [4] was shared earlier... :P
Sorry, I really thought the people in this WG were familiar with mapping
things from one domain to another as this is the core problem here. I also
now understand why nobody was really following me when I was asking about
defining the input and the output of the direct mapping :-)
My background is in computer languages, logic and formal proofs. Maybe
these techniques are too familiar to me and I assumed too much. Sorry
about that...
Alexandre.
[5] http://en.wikipedia.org/wiki/Set-builder_notation
[6] http://en.wikipedia.org/wiki/Abstract_data_type
>
>
>> Alexandre.
>>
>> [3] http://www.w3.org/TR/2010/WD-rdb-direct-mapping-20101118/#alg
>> [4]
>> http://homepages.inf.ed.ac.uk/wadler/papers/xsl-semantics/xsl-semantics.pdf
>>
>>
>> >
>> >
>> > [1] http://www.w3.org/2011/02/16-DM-denotational-rdf-semantics
>> > [2] http://www.w3.org/TR/2010/WD-rdb-direct-mapping-20101118/#RDFdef
>> >
>> >
>> > Juan Sequeda
>> > +1-575-SEQ-UEDA
>> > www.juansequeda.com
>> >
>> >
>> > On Wed, Feb 16, 2011 at 2:14 PM, Juan Sequeda <juanfederico@gmail.com>
>> > wrote:
>> >
>> >
>> > On Wed, Feb 16, 2011 at 1:56 PM, Alexandre Bertails
>> > <bertails@w3.org> wrote:
>> > On Wed, 2011-02-16 at 13:50 -0600, Juan Sequeda wrote:
>> > > On Wed, Feb 16, 2011 at 1:26 PM, Alexandre Bertails
>> > <bertails@w3.org>
>> > > wrote:
>> > > Hi Juan,
>> > >
>> > > On Wed, 2011-02-16 at 13:15 -0600, Juan
>> > Sequeda wrote:
>> > > > Alex, Eric
>> > > >
>> > > >
>> > > > Can you guys clarify some issues that I'm
>> > not understanding
>> > > correctly.
>> > >
>> > >
>> > > It's funny you ask these things right after
>> > I sent [1] :-)
>> > >
>> > >
>> > >
>> > > Yes, what a coincidence. You sent your email 1 hour
>> > ago. I've been
>> > > working on this for the last two.
>> > >
>> > > I suggest you follow [2] instead of what you
>> > found in the
>> > > current draft.
>> > > This is an updated version (far simpler and
>> > much more
>> > > complete) and I'll
>> > > be happy to help you going through it.
>> > >
>> > >
>> > > Damn.. 2 hours of work down the drain....
>> >
>> >
>> > Sorry for that :-/
>> >
>> >
>> > Np. Not your fault ;)
>> >
>> > One good indication of our work is to follow the
>> > activity on the
>> > repository. We don't produce the maths without having
>> > the corresponding
>> > code and tests. This part is now living in the
>> > "no_hierarchy" branch but
>> > I plan to merge that into the default one in the next
>> > days. That will
>> > also update the web application but this will be
>> > transparent, as both
>> > branches pass exactly the same test-suite.
>> >
>> >
>> > ok
>> >
>> >
>> > Alexandre.
>> >
>> >
>> >
>> > >
>> > >
>> > > Alexandre Bertails.
>> > >
>> > > [1]
>> > http://www.w3.org/mid/1297880900.11894.25.camel@simplet
>> > > [2]
>> >
>> http://www.w3.org/2011/02/16-DM-denotational-rdf-semantics
>> > >
>> > >
>> > > >
>> > > >
>> > > > Thanks!
>> > > >
>> > > >
>> > > > I'm going to use this as my
>> > > > example:
>> > >
>> >
>> http://www.w3.org/TR/2010/WD-rdb-direct-mapping-20101118/#lead-ex
>> > > >
>> > > >
>> > > > First, I'm going to define a Database
>> > Model, following:
>> > > >
>> > >
>> >
>> http://www.w3.org/TR/2010/WD-rdb-direct-mapping-20101118/#Rel
>> > > >
>> > > >
>> > > > Database = {"Address -> Table1, "People"
>> > -> Table2}
>> > > >
>> > > >
>> > > > Table1 = (Header1, 0, [id], 0, Body1)
>> > > > Header1 = {id -> int, city -> char, state
>> > ->char}
>> > > > Body1 = [Tuple1, Tuple2]
>> > > > Tuple1 = {id -> 18, city -> Cambridge,
>> > state -> MA}
>> > > > Tuple2 = {id -> 19, city -> Austin, state
>> > -> TX}
>> > > >
>> > > >
>> > > > Table2 = {Header2, 0, [id], FK2, Body2)
>> > > > Header2 = {id -> int, fname -> char, addr
>> > -> int}
>> > > > FK2 = { [addr] -> (Table1, [id]) }
>> > > > Body2 = [Tuple3, Tuple4, Tuple5]
>> > > > Tuple3 = {id -> 7, fname -> Bob, addr ->
>> > 18}
>> > > > Tuple4 = {id -> 8, fname -> Sue, addr ->
>> > null}
>> > > > Tuple5 = {id -> 9, fname -> Joe, addr ->
>> > 19}
>> > > >
>> > > >
>> > > > So lets start!
>> > > > [23]
>> > > > directDB()
>> > > > â‰
>> > > > { directR(R, M) ∣
>> > > > R ∈ DB }
>> > > >
>> > > >
>> > > > First of all, I do not know what M is. I'm
>> > assuming that DB
>> > > is the
>> > > > Database, therefore:
>> > > >
>> > > >
>> > > > R = {"Address -> Table1, "People" ->
>> > Table2}
>> > > >
>> > > >
>> > > > If I understand the notation correctly,
>> > then:
>> > > >
>> > > >
>> > > > directDB() = {directR("Address -> Table1,
>> > M),
>> > > directR("People" ->
>> > > > Table2, M)}
>> > > >
>> > > >
>> > > > so let's do the first directR
>> > > >
>> > > >
>> > > > 24]
>> > > > directR(R, M)
>> > > > â‰
>> > > > { directT(T, R,
>> > > > M) ∣ T ∈ R.Body }
>> > > >
>> > > > I'm still unclear what is M
>> > > >
>> > > >
>> > > > What is R.Body? I'm assuming you are
>> > retrieving Body.
>> > > Therefore Body
>> > > > of Table1 is [Tuple1, Tuple2], therefore I
>> > assume:
>> > > >
>> > > >
>> > > > T = [Tuple1, Tuple2]
>> > > >
>> > > >
>> > > > now we have:
>> > > >
>> > > >
>> > > > directR("Address -> Table1, M) =
>> > { directT([Tuple1, Tuple2],
>> > > "Address
>> > > > -> Table1, M) }
>> > > >
>> > > >
>> > > > now let's go to the definition of directT
>> > > >
>> > > >
>> > > > 25]
>> > > > directT(T, R, M)
>> > > > â‰
>> > > > { directS(S, T,
>> > > > R, M) ∣ S =
>> > > > subject(T, R,
>> > > > M) }
>> > > >
>> > > >
>> > > > now we need to know what is S
>> > > >
>> > > >
>> > > > 26]
>> > > > subject(T, R, M)
>> > > > â‰
>> > > > if (pk(R) =
>> > > > ∅) then new blank
>> > > > node else rowIRI(R, T[pk(R)]) # references
>> > the ultimate
>> > > referent of hierarchical key
>> > > >
>> > > >
>> > > > What is pk(R)?
>> > > >
>> > > >
>> > > > now we have:
>> > > >
>> > > >
>> > > > subject([Tuple1, Tuple2], "Address ->
>> > Table1, M) = if
>> > > (pk("Address ->
>> > > > Table1) = 0
>> > > >
>> > > > then new blank node
>> > > >
>> > > > else
>> > > >
>> > > > rowIRI("Address -> Table1,
>> > T[pk("Address ->
>> > > Table1)])
>> > > >
>> > > >
>> > > >
>> > > >
>> > > > I'm assuming tat pk("Address -> Table1)
>> > will return the
>> > > primary key,
>> > > > then we have
>> > > >
>> > > >
>> > > > pk("Address -> Table1) = [id]
>> > > >
>> > > >
>> > > > Now we have
>> > > >
>> > > >
>> > > > subject([Tuple1, Tuple2], "Address ->
>> > Table1, M) =
>> > > rowIRI("Address ->
>> > > > Table1, T[[id]])
>> > > >
>> > > >
>> > > > Now let's go to the definition of rowIRI
>> > > >
>> > > >
>> > > > [31]
>> > > > rowIRI(R, As)
>> > > > â‰
>> > > > IRI(UE(R.name) +
>> > > > "/" + (join(',',
>> > > > UE(A.name) + "="
>> > > > + UE(A.value)) ∣
>> > > > A ∈ As ) + "#_")
>> > > >
>> > > >
>> > > > What is UE()?
>> > > >
>> > > >
>> > > > What is R.name? Where is it defined?
>> > > >
>> > > >
>> > > > Ok, I'm stopping here.
>> > > >
>> > > >
>> > > > p.s. By the time I finished doing all of
>> > this, I saw that
>> > > Alex sent an
>> > > > email with a new version of the
>> > denotational semantics. I'm
>> > > guessing I
>> > > > should re-do what I just did with the new
>> > version?
>> > > >
>> > > >
>> > > > Thanks guys for the clarifications!
>> > > >
>> > > >
>> > > > Juan Sequeda
>> > > > +1-575-SEQ-UEDA
>> > > > www.juansequeda.com
>> > > >
>> > > >
>> > >
>> > >
>> > >
>> > >
>> >
>> >
>> >
>> >
>> >
>> >
>>
>>
>>
>>
>>
>>
>
Received on Thursday, 17 February 2011 19:54:03 UTC