SV_MEETING_TITLE -- 07 May 2009

<AxelPolleres> http://www.w3.org/2009/sparql/wiki/F2F1_Agenda#Day_2

<iv_an_ru> Shouldn't we add some way of returning quads, not triples, say, in TriG ?

<iv_an_ru> ( I know that's not in the agenda so I'm asking before we've started ;)

<iv_an_ru> Михайлов

<AxelPolleres> http://www.w3.org/2009/sparql/wiki/F2F1_Agenda#Day_2

<LeeF> ScribeNick: pgearon

<ericP> tx

<AndyS> Could use a result set of GSPO.

<iv_an_ru> yes, we could, but there's no standard loader for that.

Axel: move feature specification template to the end of the day. Start with subselects and aggregates today

<AxelPolleres> http://www.w3.org/2009/sparql/wiki/Feature:SubSelects

<AxelPolleres> http://jena.sourceforge.net/ARQ/sub-select.html

AndyS: ARQ subselects work in together with rest of the query
... projected variables from a select show up in the global select

<AndyS> Slides: http://jena.hpl.hp.com/~afs/SPARQL-F2F1-AFS.pdf

<iv_an_ru> Virtuoso allows ASK and SELECT in filters, but not CONSTRUCT in FROM (but it will soon).

AndyS: Jena uses "funny" generated variable names to represent aggregates like count eg. ?.0

<AxelPolleres> we are at the example on slide 9

<AxelPolleres> discussion about whether curly brackets needed around subselects.

<iv_an_ru> I'd prefer mandatory brackets to keep indentation rules uniform.

Jena doesn't require the curly braces, but people find the brackets aesthetically pleasing

AndyS: to make the grammar work you just have to remove the prohibition against subselects

AxelPassant: concern about blank nodes?

<iv_an_ru> bnodes are not a problem because they're "persistent enough" to stay uniform during run of query and all its subselects.

<AxelPolleres> Axel: question about variable name scopes in subselcts on variables NOT projected.

<AxelPolleres> ... similar to disallow bnodes.

<JanneS> hi there

ericP: does project happen early or late in the query

<iv_an_ru> In Virtuoso, what's inside a subquery and not returned is local to the subquery.

AndyS: went with the SQL approach

<iv_an_ru> (it's possible to force an error if a variable name is used in two different subselects but not in "joined" result-sets).

AndyS: no other forms of subqueries yet
... would like ASK, but see no point in CONSTRUCT

Axel: thinks CONSTRUCT makes sense due to creating groups around a blank node

<iv_an_ru> For debugging, it may be convenient to permit "{ select ... where { ?x ?y ?z } ... } AS <alias> to see ?alias.x, ?alias.y ?alias.z in the debugger, but that is incovenient in other aspects.

<AxelPolleres> http://www.polleres.net/publications/poll-etal-2007.pdf page 6, example for COSTRUCT in FROM

<Zakim> LeeF, you wanted to ask about RDF datasets for subqueries

<iv_an_ru> we're thinking about FROM ?g { construct { ?s ?p ?o }}...

AndyS: no selects in filters. It's a conservative implementation

<iv_an_ru> Selects in filters are very convenient.

<AxelPolleres> discussion: FROM in subqueries and subwueries in FROM

<iv_an_ru> Moreover, select in filter is LIMIT 1 for its parameters, that's a very good hint for optimizer.

<LeeF> issues i've noted so far to be discussed: syntax, variable scope, ASK queries in filters, SELECT queries in FILTER, CONSTRUCT in FROM, CONSTRUCT in CONSTRUCT, defining (new) RDF dataset in subqueries

<LeeF> issues i've noted+: order of result set for subqueries

AndyS: order in a subquery doesn't do much, but with limit 1 this is a useful optimization

<AxelPolleres> virtuoso:

<AxelPolleres> subqueries in filters, subqueries in graph patterns

iv_an_ru: discussing subselect in virtuoso

<AxelPolleres> ... sounds overall similar to ARQ, yes?

<AxelPolleres> one-result-subselects in FILTERS as well as ASK, yes?

iv_an_ru: if result contains aggregate and non-aggregate columns, performs search for groupings

<AxelPolleres> groupings automatically?

iv_an_ru: possible to specify groupings manually
... parameters available in normal select and in subselect

subselects allow only 1 returned column when in a filter

<AxelPolleres> implied "limit 1" i.e. "EXISTS"

AndyS: lets you ask "?x IN { SELECT..... }"

<AxelPolleres> IN {subselects} allowed, but no others like ANY/ALL

iv_an_ru: does not implement CONSTRUCT in subqueries yet, but intends to offer soon, though in different way to what was discussed earlier

<AxelPolleres> ivan talking avbout FROM ?g { construct { ?s ?p ?o }}...

iv_an_ru: should be possible to have more than one CONSTRUCT and to test if a triple is found in more than one source

<Zakim> LeeF, you wanted to ask iv_an_ru what they do re: subqueries defining data set

LeeF: can you define the dataset to query over, and how does this interact

iv_an_ru: if from / from named specified then this is used instead of specified data

<AxelPolleres> LeeF: design issue for dataset in query vs. dataset in protocol

<AndyS> sec 8.2: "the protocol description overrides any description in the query itself."

<LeeF> iv_an_ru: a few possible ways to specify dataset

<LeeF> ... by pragma, http param, by query text

<LeeF> ... latter 2 as per spec

<LeeF> ... prgama is higher priority

<AxelPolleres> iv_an_ru: Virtuoso allows dataset in prgamas, parameters, in the query, pragmas of highest priority

<LeeF> ... common for selects & subselects

<iv_an_ru> ups, will try to reconnect.

<AxelPolleres> all I found for SeRQL subselects is here: http://www.openrdf.org/doc/sesame/users/ch06.html

<LeeF> pgearon: in mulgara subqueries are at an API level

<LeeF> ... for every binding in a result set, do var. substitution into a subselect

<LeeF> ... then execute subselect for each row in the outer result

<AxelPolleres> paul: in mulgara subselects on the API level.

<LeeF> ... if the subselect returns multiple rows, they're all returned, column is not a scalar type, it's a "subanswer"

<LeeF> ... if you're printing results as a table then you get a subtable in that particular column

<LeeF> AndyS: Effectively have tables in the datatype model?

<LeeF> pgearon: yes

<LeeF> pgearon: for aggregates we have COUNT which works on a subselect

<LeeF> ... subselect takes variable subst from outer select (as before), executes entire query, and returns count of rows as a scalar

<LeeF> AndyS: So Count is special case?

<LeeF> pgearon: yes

<LeeF> pgearon: subselects appear in SELECT clause not in WHERE clause

LeeF, thanks

<LeeF> np

<AxelPolleres> simon about http://www.openrdf.org/doc/sesame/users/ch06.html#section-nesting

SimonS: Sesame allows subqueries in both graph pattern and filters

no syntax extension for SPARQL only in SeRQL

<AxelPolleres> andy/steve: scoping for unions might be different.

scribe: can have set minus, and unions in graphs
... has ANY and ALL, also has EXISTS

<AxelPolleres> simon: exists seems redundant with any.

scribe: evaluates subqueries in the graph pattern, but this can't be accessed

<JanneS> (will be back shortly)

scribe: scoping shared with subqueries

datasets are shared between main query and subqueries

<AxelPolleres> ?x > ANY ..

<AxelPolleres> ?x > ALL ...

AxelPolleres: thinks this makes ANY not redundant

SimonS: says variables are shared (no scoping) which means that ANY can be described in other ways

<AxelPolleres> simon: ANY could be wrapped into EXISTS with normal FILTER... cause of scoping

<SimonS> http://www.openrdf.org/doc/sesame/users/ch06.html#section-setoper

<SimonS> set operators.

<AxelPolleres> Steve: comp ALL could be emulated with negation.

AndyS: you can do MAX in SPARQL if you have too much time on your hands

<LeeF> AndyS: you can do MAX in SPARQL if you have too much time on your hands

<LeeF> AndyS: you can do max in SPARQL if you have too much time on your hands

<LeeF> AndyS: asdfgh

LeeF: will be doing subqueries by the end of this weekend

<AxelPolleres> grepg, Lee, Eric don't do subqueries...

<LeeF> AndyS: to you can do MAX IN SPARQL if you ahve too much time on your hands

<LeeF> that's weird

<Zakim> SimonS, you wanted to add something

SimonS: SeRQL has full syntax for subqueries, including limits, from, etc

<AxelPolleres> AndyS: FROM in subqueries wrong with the algebra.

Mulgara's subqueries only use data from the FROM clause in the subselect

<iv_an_ru> AxelPolleres, we don't have to make the support of FROM in subselect mandatory for all implementations.

<iv_an_ru> Anyway we have huge amount of implementation-specific options related to FROM / FROM NAMED.

<AxelPolleres> AndyS: answer of this issue depends on use cases which demand FROM in subselect.

<iv_an_ru> FROM is subselect is no more than a syntax sugar, because it's possible to list everything in top-level FROM and add different FILTERs on graphs to different subselects.

SimonS: federation works be defining "magic name graphs" which can be defined from more than one graph. This makes it a kind of subquery

<AxelPolleres> SimonS: subqueries play some role for federated queries.

<iv_an_ru> I'd name it "federated-per-subquery"

<iv_an_ru> SERVICE {} and {SELECT ...} are too similar.

<SimonS> +1 iv_an_ru

AxelPolleres: now we've discussed existing implementation we should move to discussion

<SteveH> Apropos of nothing I slightly prefer a subquery syntax like SUB { SELECT ... } which is much more obviously similar to SERVICE <> { SELECT ... }

<iv_an_ru> SteveH, it may be { SELECT ... FROM SERVICE <> ... }

<SteveH> oh, good point

<SteveH> or { FROM SERVICE <> SELECT ... } equivalently

<iv_an_ru> SERVICE clause may heve enormous list of options so it should allow more verbosity than just a single IRI. Moreover, even that IRI may be a scalar-expression.

LeeF: issues to be discussed. Start with 1) syntax

<LeeF> ISSUE: subquery syntax (e.g. mandatory curly braces)

<trackbot> Created ISSUE-3 - Subquery syntax (e.g. mandatory curly braces) ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/3/edit .

<AxelPolleres> subqueries in patterns:

<AxelPolleres> SUBSELECTS as solutions sets

<AxelPolleres> subqueries in FILTERS:

<AxelPolleres> ASK (EXISTS), IN, ANY, ALL

<AxelPolleres> subqueries in FROM:

<AxelPolleres> CONSTRUCT

KjetilK_Lap: wants a description of the motivation for this issue

AxelPolleres: which type of queries will we allow?

<bglimm> For me the issue shows a drop down box for who raised it and Baget is alphabetically first

LeeF: what variable scope to use between main query and subqueries?

<LeeF> ISSUE: What is the variable scope between main queries and subqueries?

<trackbot> Created ISSUE-4 - What is the variable scope between main queries and subqueries? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/4/edit .

<LeeF> ISSUE: ASK queries in FILTERs?

<trackbot> Created ISSUE-5 - ASK queries in FILTERs? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/5/edit .

<LeeF> ISSUE: SELECT queries in FILTERs?

<trackbot> Created ISSUE-6 - SELECT queries in FILTERs? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/6/edit .

<LeeF> ISSUE: CONSTRUCT & DESCRIBE queries in FROM [NAMED]?

<trackbot> Created ISSUE-7 - CONSTRUCT & DESCRIBE queries in FROM [NAMED]? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/7/edit .

<LeeF> ISSUE: What determines the RDF dataset for subqueries?

<trackbot> Created ISSUE-8 - What determines the RDF dataset for subqueries? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/8/edit .

<LeeF> ISSUE: SELECT queries in graph patterns?

<trackbot> Created ISSUE-9 - SELECT queries in graph patterns? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/9/edit .

<LeeF> ISSUE: ASK queries in graph patterns?

<trackbot> Created ISSUE-10 - ASK queries in graph patterns? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/10/edit .

AxelPolleres: suggesting champions for each type of subselect, aggregates, etc

<LeeF> pgearon: Do we allow some way to count the entire results of a subquery?

LeeF: syntax? should we use { SELECT ... } ?

SteveH: preference for a keyword before a subquery

<iv_an_ru> Preference for keyword inside {} because most of customers have SQL background.

question about whether braces should be mandatory

AndyS: scoping evaluation should be handled in terms of overall evaluation (so look at that question first)

LeeF: are variables that are only in a subquery, local to just that subquery?

<LeeF> ?p a foaf:Person . { SELECT ?name { ?p a ex:Airport ; dc:title ?name } }

so "select *" will only get projected variables from a subquery

<AxelPolleres> Andy: would * not propagate variables from subqueries that are not projected...

<iv_an_ru> Yes, local-only variables are local :)

<iv_an_ru> * is a shorthand for variables that may be bound in WHERE {...} top-level pattern, so what's the issue?

<LeeF> how to use trackbot

AndyS: unprojected variables in an outer query will not be available in a subquery

<LeeF> ISSUE-3: <seems to be general consensus around mandatory curly braces and no "subqyery keyword"

<trackbot> ISSUE-3 Subquery syntax (e.g. mandatory curly braces) notes added

<LeeF> ISSUE-4: general consensus around the fact that non-projected variables in a subquery are not visible outside the subquery

<trackbot> ISSUE-4 What is the variable scope between main queries and subqueries? notes added

<AxelPolleres> Andy: in DB engines join is commutative, so order-dependance is bad for optimizations

<SimonS> CONSTRUCT

<SimonS> { ?X ex:hasFriends

<SimonS> {COUNT ?X WHERE ?P foaf:knows ?X}

<SimonS> }

<SimonS> WHERE {?P a foaf:Person}

AndyS: outer variables would affect joins. So outer evaluation first would make it impossible to implement with an SQL engine, due to impossibility to do join optimization

<iv_an_ru> It should be possible to begin with subqueries.

<AndyS> +1 to iv_an_ru -- clear cut semantics

<SimonS> CONSTRUCT { ?P ex:hasFriends ?F } WHERE { ?P a foaf:Person. SELECT COUNT(?X) AS ?F WHERE { ?P foaf:knows ?X } }

<LeeF> SteveH: preseve join semantics, consequence of that is that unprojected variables don't leak out

SteveH: want to protect join semantics, which implies that unprojected variables are not seen

<AndyS> Same issue as { {?x :p ?v } { ?x :q ?w FILTER (?v>3) }

<iv_an_ru> SimonS, shuold be just CONSTRUCT { ?P ex:hasFriends ?F } WHERE { SELECT ?P, COUNT(?X) AS ?F WHERE { ?P foaf:knows ?X } }

<AndyS> Same issue as { {?x :p ?v } { ?x :q ?w FILTER (?v>3) } }

AndyS: generate test cases soon?

SteveH: may be too soon for syntax

AxelPolleres: would like example queries with scoping issues

LeeF: will write example

<AndyS> { {?x :p ?v } { SELECT * { ?x :q ?w FILTER (?v>3) } } }

<LeeF> ACTION: LeeF to send fleshed out example of Andy's subquery to the list { {?x :p ?v } { SELECT * { ?x :q ?w FILTER (?v>3) } } } [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action01]

<trackbot> Created ACTION-16 - Send fleshed out example of Andy's subquery to the list { {?x :p ?v } { SELECT * { ?x :q ?w FILTER (?v>3) } } } [on Lee Feigenbaum - due 2009-05-14].

<iv_an_ru> AndyS, Virtuoso would raise an error in debug mode.

<AndyS> { ?x :p ?v { SELECT * { ?x :q ?w FILTER (?v>3) } } }

AndyS, Mulgara would be fine, given that it prebinds ?x and ?v before executing the subselect

should that be detected, and used to determine evaluation order?

Or does that preclude SQL engines?

<AxelPolleres> { ?x :p ?v { SELECT * { ?x :q ?w FILTER (?v>?w) } } } more interesting?

<AndyS> pgearon, so not relational algebra evalaution?

<iv_an_ru> No evaluation order should be assumed --- keep the optimizer's hands free from that.

<SteveH> +1

AndyS, well.... I'm just raising it as a possibility :-)

<AndyS> :-)

<iv_an_ru> AxelPolleres, in your variant Virtuoso will treat ?v in subselect as a constant NULL (and it can report the suspicious variable as an error).

after all, it makes sense in some circumstances. I like Axel's example

<AxelPolleres> SteveH: concern about ASK in FILTER raises scoping question

<LeeF> ACTION: SteveH to write up case around confusion between ASK in FILTER and ASK in WHERE [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action02]

<trackbot> Created ACTION-17 - Write up case around confusion between ASK in FILTER and ASK in WHERE [on Steve Harris - due 2009-05-14].

<iv_an_ru> What's the purpose of ASK in WHERE ?

<AndyS> Hmm - had better scope variables locally in negation if unmentioned elsewhere

<SteveH> With a URI?

<LeeF> ISSUE-5: See ACTION-17

<trackbot> ISSUE-5 ASK queries in FILTERs? notes added

<AxelPolleres> ACTION: AxelPolleres to write up a use case on !ASK in FILTERS to emulate negation [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action03]

<trackbot> Sorry, couldn't find user - AxelPolleres

<AxelPolleres> ACTION: Axel to write up a use case on !ASK in FILTERS to emulate negation [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action04]

<trackbot> Created ACTION-18 - Write up a use case on !ASK in FILTERS to emulate negation [on Axel Polleres - due 2009-05-14].

<LeeF> ISSUE-5?

<trackbot> ISSUE-5 -- ASK queries in FILTERs? -- OPEN

<trackbot> http://www.w3.org/2009/sparql/track/issues/5

<ericP> good bot

<LeeF> ISSUE-5: See ACTION-18 for interplay with negation

<trackbot> ISSUE-5 ASK queries in FILTERs? notes added

AxelPolleres: to issues 6 - select queries on filters

<KjetilK_Lap> iv_an_ru, could you please post some examples of SELECT queries in FILTERs?

<LeeF> iv_an_ru, I wonder if you could send to the mailing list a few example cases (data, query, results) of SELECT queries in FILTERs?

<iv_an_ru> ok

<LeeF> ACTION: iv_an_ru to send to the mailing list a few example cases (data, query, results) of SELECT queries in FILTERs [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action05]

<trackbot> Created ACTION-19 - Send to the mailing list a few example cases (data, query, results) of SELECT queries in FILTERs [on Ivan Mikhailov - due 2009-05-14].

<LeeF> ISSUE-6: See ACTION-19

<trackbot> ISSUE-6 SELECT queries in FILTERs? notes added

<AxelPolleres> AndyS: suggest to use ALL/ANY queries for that

<LeeF> ISSUE-7?

<trackbot> ISSUE-7 -- CONSTRUCT & DESCRIBE queries in FROM [NAMED]? -- OPEN

<trackbot> http://www.w3.org/2009/sparql/track/issues/7

<iv_an_ru> Something real-life or as simple as possible?

<LeeF> iv_an_ru, both? I prefer simple to real-life though :)

<iv_an_ru> ok

<AxelPolleres> CONSTRUCT { ?a knows ?b . ?a foaf:name ?aname . ?b foaf:name ?bname . }

<AxelPolleres> FROM { CONSTRUCT { _:auth foaf:name ?n . ?p aux:hasAuthor _:auth . }

<AxelPolleres> FROM <g> WHERE { ?p dc:creator ?n . } }

<AxelPolleres> WHERE { ?p aux:hasAuthor ?a . ?a foaf:name ?aname .

<AxelPolleres> ?p aux:hasAuthor ?b . ?b foaf:name ?bname . FILTER ( ?a != ?b ) }

LeeF: should construct and describe in from be allowed?

<LeeF> ACTION: AxelPolleres to send CONSTRUCT in FROM clause use case to mailing list re: ISSUE-7 [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action06]

<trackbot> Sorry, couldn't find user - AxelPolleres

<LeeF> ACTION: Axel to send CONSTRUCT in FROM clause use case to mailing list re: ISSUE-7 [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action07]

<trackbot> Created ACTION-20 - Send CONSTRUCT in FROM clause use case to mailing list re: ISSUE-7 [on Axel Polleres - due 2009-05-14].

<LeeF> ISSUE-8?

<trackbot> ISSUE-8 -- What determines the RDF dataset for subqueries? -- OPEN

<trackbot> http://www.w3.org/2009/sparql/track/issues/8

can that include examples on DESCRIBE in a FROM? I don't follow that one

<LeeF> ACTION: LeeF to summarize dataset issue w/ examples / suggestions per ISSUE-8 [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action08]

<trackbot> Created ACTION-21 - Summarize dataset issue w/ examples / suggestions per ISSUE-8 [on Lee Feigenbaum - due 2009-05-14].

<LeeF> ISSUE-9?

<trackbot> ISSUE-9 -- SELECT queries in graph patterns? -- OPEN

<trackbot> http://www.w3.org/2009/sparql/track/issues/9

<LeeF> ISSUE-10?

<trackbot> ISSUE-10 -- ASK queries in graph patterns? -- OPEN

<trackbot> http://www.w3.org/2009/sparql/track/issues/10

<LeeF> ISSUE-10: See ACTION-17

<trackbot> ISSUE-10 ASK queries in graph patterns? notes added

aggregates

<AlexPassant> scribe: AlexPassant

<LeeF> ScribeNick: AlexPassant

LeeF: Overview of existing systems that do aggregates
... what the syntax is like, which aggregates are supported
... and any relevant information for each approach

SteveH: COUNT, MIN, MAX
... restricted to particular subtypes
... COUNT * is mainly used
... using Dave Beckett syntax

<SteveH> (COUNT(DISTINCT *)) AS c

LeeF: do you group by

SteveH: no
... implemented for a particular use-case

AxelPolleres: implcit grouping ?

SteveH: distinct is a kind of

<AxelPolleres> SELECT ?x (count... ) not possible, yes?

AndyS: no grouping, same value on each row

LeeF: distinct in some implementations to remove duplicates, then group and aggregates,
... having clause for values that don't match the criteria

<AxelPolleres> LeeF: summarizes possiblities for aggregates in SQL: aggregates, groupin, having clauses

AndyS: GROUPing, then aggregates to each of the group
... implements 4 variations of COUNT
... don't think average is done
... issues around MIN and MAX on different types (eg: string / age)

<pgearon> COUNT - variable, *, distinct, non-distinct

LeeF: implicit grouping ?

AndyS: if there's no GROUP , the whole thing is a group
... implements HAVING

<Zakim> ericP, you wanted to ask if you can do e.g. count and avg on the same group

<AndyS> http://jena.hpl.hp.com/~afs/SPARQL-F2F1-AFS.pdf slide 6+

ericP: can you do more than one aggregate on the same group

AndyS: yes - it should work

SteveH: wondering if someone implements GROUP_CONCAT() ?
... perl-style join
... different from the regular CONCAT as it works on GROUP

<Zakim> LukeWM, you wanted to ask about ask

LukeWM: do you combine ASK and HAVING ?

AndyS: it could be done

<Zakim> pgearon, you wanted to ask if you can do subselects in having

pgearon: subselects in a having ?

<pgearon> I'll try to write a subquery to be executed in a having clause that causes execution order problems

AndyS: COUNT is the most-used aggregate

<AxelPolleres> Issues I noted so far:

<AxelPolleres> * GROUP By vs 1 column only

<AxelPolleres> * implicit grouping vs explicit only

<AxelPolleres> * HAVING clauses

<AxelPolleres> * several aggregates per GROUP

<AxelPolleres> * GROUP concat ... could be generalized to other functions on sequences from XPath/Xquery

<LeeF> ACTION: Paul to write a subquery to be executed in a having clause that causes execution order problems for the list [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action09]

<AxelPolleres> * subqueries in HAVING analogous to subqueries in FILTERs)

<trackbot> Created ACTION-22 - Write a subquery to be executed in a having clause that causes execution order problems for the list [on Paul Gearon - due 2009-05-14].

<AxelPolleres> * paul's example for problems with HAVING...? (more an ACTION on the previous than an own issue, it seems)

LeeF: OpenAnzo : similar to AndyS approach, GROUPing needs to be expressed
... implements COUNT (differnt versions), SUM,
... AVERAGE, MIN, MAX
... SAMPLE (says I want to group by but want only one random example in that row)

see: http://www.w3.org/2009/sparql/wiki/Feature:SampleAggregate
... should also implement HAVING
... AVERAGE DISTINCT is also supported

<Zakim> SteveH, you wanted to talk about projecting non-grouped variables

SteveH: prohibiting to project non-grouped variables

<Zakim> SimonS, you wanted to ask whether SAMPLE can be done usng subselect LIMIT 1

SimonS: could sample be done with SUBSELECT + LIMIT 1 ?

AndyS: It shouldn't be due to the grouping

<Zakim> AxelPolleres, you wanted to ask whether SAMPLE is nondeterministic?

LeeF: SAMPLE is explicitely non deterministic

<SteveH> otherwise you can't ORDER BY rand(), which is v. important

<LeeF> AlexPassant: ARC2 implements average, min, max, sum

http://arc.semsol.org/docs/v2/sparql+

<AxelPolleres> Axel: a bit worried about nondet, but REDUCED, LIMIT without ORDER are also already nondet.

<LeeF> ... count too

scribe: GROUP BY is mandatory

<SteveH> and DESCRIBE

kasei: RDF::Query implements MIN, MAX, AVERAGE

AndyS: what about "MIN of a string" of "MIN of number" ?

kasei: that is possible also if you cast the value

AndyS: different point of view, not about casting, but about querying for the right type

<Zakim> AxelPolleres, you wanted to ask about whether this is type promotion in the sense of http://www.w3.org/TR/xpath20/#promotion

<Zakim> AndyS, you wanted to say "no it isn't" :-)

AxelPolleres: we could follow the promotion rule in some cases

LeeF: will go through AndyS slids and check AxelPolleres e-mail proposal

<AndyS> I think we have (almost) to because the rest of evaluation does in FILTER.

<AxelPolleres> s/the promotion rule/the promotion rules from http://www.w3.org/TR/xpath20/#promotion/

<AxelPolleres> Issues I noted so far:

<AxelPolleres> * GROUP BY vs 1 column only

<AxelPolleres> * implicit grouping vs explicit only

<AxelPolleres> * HAVING clauses

<AxelPolleres> * several aggregates per GROUP

<AxelPolleres> * GROUP concat ... could be generalized to other functions on sequences from XPath/Xquery

<AxelPolleres> * subqueries in HAVING analogous to subqueries in FILTERs)

<AxelPolleres> * paul's example for problems with HAVING...? (more an ACTION on the previous than an own issue, it seems)

<AxelPolleres> * which aggregates? COUNT (which version?), SUM, AVG, MIN, MAX, SAMPLE (nondeterministic)

<AndyS> http://jena.hpl.hp.com/~afs/SPARQL-F2F1-AFS.pdf // slide 9

<LeeF> http://jena.hpl.hp.com/~afs/SPARQL-F2F1-AFS.pdf

<AxelPolleres> * datatype promotion/implicit casts for arithmetic aggregates? e.g. min over strings and numbers, avg over integers, etc.

AndyS: slide 9, highlighted part in the algebra is the subselect part
... got filter, having, group,
... list of aggregates operator and temporary variables
... group is covered (phase 1: turn everything into group)
... then calculate aggregate values
... then asign temp variables

LeeF: have a similar implementation

AndyS: can only aggregate over things that are not grouped

LeeF: expected subqueries to be harder to implement than aggregates

AndyS: should depend on the implementation

http://www.polleres.net/presentations/20090506SPARQL_aggregates_as_subqueries.pdf

AxelPolleres: do we want to go syntaxically to SQL or to declarative logic programming ?
... proposal: aggregate subqueries
... { AGG Vars WHERE Pattern } 
... example on slide #3
... should be ?P ex:hasFriends

SteveH: how do you control the projection of P, that will appear inside the subselect

AxelPolleres: bindings of the overall query will be replaced in the CONSTRUCT
... can have nested queries with FILTER and aggregate
... not sure I can nest aggregates

<Zakim> LukeWM, you wanted to ask about scoping

AxelPolleres: what I like about it: being inspired by logical programming
... not as intuitive for people coming from SQL

ericP: expressivity issue (e.g. duplicate) may be a problem
... the WHERE clause is an arbitrary pattern

<Zakim> AndyS, you wanted to ask about a use case

AndyS: how do you write query like "how many people live in each places" based on a people / place dataset

<SteveH> a minor drawback if that impl. don't get to add their own aggregate functions without adding keywords to that language

AxelPolleres: GROUP BY is implicit, done by the subquery
... don't know how to group by expression

bglimm: is that computionnaly more expensive ?
... need to compute subqueries and then compute

SteveH: optimiser can do that job

bglimm: it should be more complex to implement efficiently

<Zakim> LeeF, you wanted to ask about grammar effects / need for a keyword

LeeF: it seems there is a general consensus for the SQL-style
... go through issues

ericP: other proposal: pushing the aggregates in the pattern, but happy with the SQL style

<Zakim> KjetilK_Lap, you wanted to note that Virtuoso has implicit GROUP BY

<KjetilK_Lap> a query in https://submarine.computas.com/mediasone-maven/trunk/scripts/munin-plugins/graphs generates http://msonetest.computas.no/munin/computas.no/msonetest.computas.no-graphs.html

KjetilK_Lap: Virtuoso got a kind of explicit GROUP BY
... grouping by type, then get count per type

<AxelPolleres> Issues I noted so far:

<AxelPolleres> * GROUP BY vs 1 column only

<AxelPolleres> * implicit vs explicit GROUPing

<AxelPolleres> * HAVING clauses

<AxelPolleres> * several aggregates per GROUP

<AxelPolleres> * subqueries in HAVING analogous to subqueries in FILTERs)

<AxelPolleres> * paul's example for problems with HAVING...? (more an ACTION on the previous than an own issue, it seems)

<AxelPolleres> * which aggregates? COUNT (which version?), SUM, AVG, MIN, MAX, SAMPLE (nondeterministic)

<AxelPolleres> * Extensibility of aggregates (with own agg. functions, e.g. GROUP concat ... could be generalized to other functions on sequences from XPath/Xquery)

<AxelPolleres> * datatype promotion/implicit casts for arithmetic aggregates? e.g. min over strings and numbers, avg over integers, etc.

<AxelPolleres> * (not) all variables need to be grouped/aggregated (the last one could well be a subissue of explicit/implicit grouping), e.g.

<AxelPolleres> SELECT ?name

<AxelPolleres> {

<AxelPolleres> { SELECT ?x

<AxelPolleres> { ?x foaf:knows?y . ?z a foaf:Person}

<AxelPolleres> GROUP BY ?x

<AxelPolleres> HAVING (count(?y) > 10)

<AxelPolleres> }

<AxelPolleres> ?x foaf:name?name

<AxelPolleres> }

LeeF: do not need an issue for the GROUP BY vs 1 column only

<LeeF> ISSUE: implicit vs explicit GROUPing

<trackbot> Created ISSUE-11 - Implicit vs explicit GROUPing ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/11/edit .

LeeF: GROUPing: imiplicit vs explicit ? creating issue
... volunteer to present the issue on the ML and telecon

<LeeF> ACTION: LeeF to summarize implicit vs. explicit grouping re ISSUE-11 [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action10]

<trackbot> Created ACTION-23 - Summarize implicit vs. explicit grouping re ISSUE-11 [on Lee Feigenbaum - due 2009-05-14].

<Zakim> kasei, you wanted to ask about HAVING syntax

<LeeF> ISSUE: presence and syntactic detail of HAVING clause

<trackbot> Created ISSUE-12 - Presence and syntactic detail of HAVING clause ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/12/edit .

<LeeF> ISSUE-12: general consensus that we need equivalent of a HAVING clause

<trackbot> ISSUE-12 Presence and syntactic detail of HAVING clause notes added

<LeeF> ISSUE: subqueries in HAVING analogous to subqueries in FILTERs

<trackbot> Created ISSUE-13 - Subqueries in HAVING analogous to subqueries in FILTERs ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/13/edit .

<AxelPolleres> examples would be nice with subwqueries in HAVING

LeeF: which aggregates ?

<LeeF> ISSUE: which aggregates to include

<trackbot> Created ISSUE-14 - Which aggregates to include ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/14/edit .

<LeeF> ISSUE: extensibility of aggregate functions

<trackbot> Created ISSUE-15 - Extensibility of aggregate functions ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/15/edit .

<LeeF> ISSUE-14: we're talking about which aggregate functions to include in SPARQL/Query

<trackbot> ISSUE-14 Which aggregates to include notes added

<LeeF> ISSUE-15: with own agg. functions, e.g. GROUP concat ... could be generalized to other functions on sequences from XPath/Xquery

<trackbot> ISSUE-15 Extensibility of aggregate functions notes added

<AxelPolleres> how about fn:concat() ... non-aggreagating , fn:concat(()) ... aggregating , or alike?

<AxelPolleres> ... not optimal, just a strawman

<LeeF> ISSUE: dealing with aggregates over mixed datatypes

<trackbot> Created ISSUE-16 - Dealing with aggregates over mixed datatypes ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/16/edit .

<LeeF> ISSUE-16: datatype promotion/implicit casts for arithmetic aggregates? e.g. min over strings and numbers, avg over integers, etc.

<trackbot> ISSUE-16 Dealing with aggregates over mixed datatypes notes added

<SteveH> AxelPolleres: x:fn((0)) is currently legal syntax

<SteveH> sorry, , not :

SimonS: is that about defining the range of aggregate functions ?

<LeeF> ACTION: AndyS to explain potential design regarding aggregate functions with multiple answers for mixed datatypes re ISSUE-16 [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action11]

<trackbot> Created ACTION-24 - Explain potential design regarding aggregate functions with multiple answers for mixed datatypes re ISSUE-16 [on Andy Seaborne - due 2009-05-14].

<KjetilK_Lap> +1 for AndyS template stuff

<SteveH> +1 for lunch

AndyS: about Feature specification template
... having a standard template helped to look at the features
... slide 11 of the pdf
... definition, syntax, operator (arguments, how it is evaluated ...), mapping abstract syntax / algebra
... then test cases

LeeF: +1 for the idea

ericP: downside is that editors need to subscribe to RSS feeds of wiki changes to make sure everything is in sync

LeeF: needs to setup a template for the wiki page

http://www.w3.org/2009/sparql/wiki/FeatureProposal

<AxelPolleres> http://www.w3.org/2009/sparql/wiki/FeatureProposal

<LeeF> ACTION: LeeF to setup wiki template and feature stub pages based on slide 11 of http://jena.hpl.hp.com/~afs/SPARQL-F2F1-AFS.pdf [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action12]

<trackbot> Created ACTION-25 - Setup wiki template and feature stub pages based on slide 11 of http://jena.hpl.hp.com/~afs/SPARQL-F2F1-AFS.pdf [on Lee Feigenbaum - due 2009-05-14].

ericP: wiki editing is protected to WG members

<LeeF> ACTION: AndyS to stub out an initial example of a filled in feature template pending completion of ACTION-25 [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action13]

<trackbot> Created ACTION-26 - Stub out an initial example of a filled in feature template pending completion of ACTION-25 [on Andy Seaborne - due 2009-05-14].

<SteveH> \o/

<AxelPolleres> +1 for lunch

<AndyS> Back in 60 mins

<ericP> http://tig.csail.mit.edu/twiki/bin/view/OOPS/VideoConference#Using_the_Video_Conferencing_Uni

<AndyS> 192.6.10.181

<ericP> i have a 10. address

<ericP> sorry, 18

<AndyS> 10 is more interesting

<ericP> SimonS1, are you using ekiga?

<SimonS1> jep.

<SimonS> just pulled out my cable it seems...

<ericP> that's ok. your 0 frame rate saved you

<SimonS> next try

<ericP> you had to sign up for an ekiga account?

<SimonS> My 0 frames double is still online. :)

<ericP> yup

<ericP> we see two of you

<SimonS> my twin disappeared

<ericP> we miss him

<ericP> so you had to sign up for an ekiga account?

<SimonS> no, you just need to sign up, if you want to be discoverable via the directory service.

<SimonS> If you are happy with IP adresses, you don't need to

<SimonS> but this way you can contact me using simonschenk@ekiga.net

<ericP> i have started ekiga and made my way through the configuration

<ericP> what did you enter to get to our conference?

<SimonS> sip:ericP@128.30.30.43

<SimonS> I guess the user is irrelevant,

<SimonS> but it is needed

<SimonS> to make a valid sip address

<ericP> sip:ericP@128.30.30.43

<AxelPolleres> We should consider publishing a sitcom...

<ericP> sip:simon@128.30.30.43 worked for me

<AxelPolleres> folks, restart in about 15mins ok?

<ericP> no way. we're having way too much fun

<LeeF> sounds good, AxelPolleres

<AxelPolleres> we will continue with Update after the break... keep these links handy for the moment:

<AxelPolleres> http://www.w3.org/Submission/SPARQL-Update/

<AxelPolleres> http://arc.semsol.org/docs/v2/sparql+

<AxelPolleres> plus Andy's slides that we used before

<AxelPolleres> for anyone planning to dial in, we are re-starting in the next minutes, jsut waiting for steve

<AxelPolleres> Do you hear us?

<SteveH> sorry, back now

<AndyS> ERIC

<ericP> awe, was i being scolded?

<KjetilK_Lap> Sce

<KjetilK_Lap> ScribeNick: KjetilK_Lap

SPARQL Update session

AxelPolleres: lets follow the same pattern
... we have the submission from AndyS and others
... AndyS, kan you take over here?

AndyS: in spite of the fact that there is a long list of supporters, this proposal is a statement of general discussion
... not a final and "best solution", so there is reason to expect changes
... SPARQL Update has the idea of an RDF graph

<AxelPolleres> relation GraphStore/Dataset 1:n? m:n?

AndyS: it has a different name, so that we don't make a tie between the query language and the update language

<AxelPolleres> protocol not yet in the submission.

AndyS: protocol not yet in the submission
... there is also a SOAP protocol for SPARQL, so we need to look into that
... doing POST is quite common

<AxelPolleres> SILENT means doesn't expect a response?

http://www.w3.org/Submission/SPARQL-Update/

AndyS walks through the submission

<LeeF> Eeeenteresting

INSERT DATA is nice if you get streams of triples without variables

<SimonS> +q to ask about multi graph documents in load

AndyS: is this the right model?
... what use cases are not covered?
... submission recommends atomic updates

<pgearon> There's no proposal for syntax around transactions?

AndyS: transactions aren't very webby?
... doesn't seem very wrong to do a lightweight solutions
... Security is a big issue

<pgearon> Mulgara takes the approach of a single updating thread, and we're regularly criticized for it

<Zakim> SteveH, you wanted to talk about PUT, when Andy's finished and to ask about CREATE GRAPH as noop and to ask about potential different between CLEAR and delete

AndyS: Virtuoso has something very close

KjetilK_Lap: we didn't make any changes when migrating

SimonS: is there any difference between being empty and being non-existent?

AndyS: yes

<AxelPolleres> empty graphs vs. quead-stores

<pgearon> I'd like to note that quad stores can have the notion of an empty graph (Mulgara does this)

<LeeF> FWIW Anzo distinguishes between empty graphs & non-existent graphs. *shrug*

SteveH: there is a difference between quad store and a triple store in this case

<AxelPolleres> like SQL DB's typically have some system tables...

pgearon: we have a system graph

AndyS: it is a issue how ambitious we are re graph management

SteveH: you can use DROP GRAPH, which is stronger than CLEAR GRAPH
... we implement PUT on the endpoint, so you can PUT triples to a graph

ericP: this is the way you can do that now, you can put on the graph URI and it updates the named graph
... the endpoint would distinguish the endpoint from the graphs by the path

<Zakim> SimonS, you wanted to ask about multi graph documents in load

SimonS: Sesame has a RESTful API where you can PUT and DELETE graphs

<SteveH> Want to add for the record, we re-use the HTTP 1.0 proxy syntax to write to other graphs

<SteveH> but it's quite ugly

<AlexPassant> YARS seems to have a similar approach that sesame - http://sw.deri.org/2004/06/yars/

<SteveH> eg. PUT http://localhost/sparql/http://foo.com/data.rdf

SimonS: MODIFY is sort of a CONSTRUCT query, right?
... i.e. the the pattern is similar
... so you cannot modify several graphs?

AndyS: yes, it is very centered around modify _a_ graph

<LeeF> How does MODIFY specify what graph receives inserted triples?

<AxelPolleres> SimonS: asks for dynamically setting the graph in MODIFY

AndyS: you will need to mix queries and update statements to do everything you need
... it is not a full-blown language for all the updates you may want to do

ericP: it should be accompanied by a media type?

AndyS: we don't know yet if it will be transported over HTTP

SimonS: you say that the default graph should always exist

AndyS: that
... that's inherited from SPARQL/Query

AxelPolleres: LOAD can't just add to all graphs

SteveH: is load additive?

AndyS: yes

AxelPolleres: issues like concurrency, is that dealt with in the submission?

AndyS: yes, it says it is atomic, but the WG must address it

AxelPolleres: graph store vs dataset, what?

AndyS: it is a difficult distinction, and I changed it many times
... you may have a huge system with many graphs, where you cannot access all graphs on any endpoint
... and you may have something that operates on just a single default graph

<Zakim> AxelPolleres, you wanted to ask about * for INTO URI

pgearon: you can have many FROMs, does that mean you delete triples from all graphs?

AndyS: it is unclear, but the idea was that you run the same operation on each graph

pgearon: I can see the use case where you SELECT from one graph to another

<LeeF> Can someone that understands this more than me type out how I would say "INSERT the foaf:knows triples from 3 different graphs into a 4th graph"? Can I say that?

<AndyS> LeeF, do as 3 operations in one request (a request is zero or more of the ops in the language)

<AxelPolleres> AndyS: insert and delete are idempotent, but not mixed together

<LeeF> AndyS, I see, thanks

<kasei> is there any reason why the grammar allows just Prologue as a valid update request?

bglimm: what is the default graph?
... it could be an empty ontology?

AndyS: yes

SimonS: do you have any idea of reusing any security mechanisms, and if so what?

AndyS: I tend to do service-based security,

<Zakim> SimonS, you wanted to ask if there are ideas of reusing some security mechanism

AndyS: i.e. not in the data, on the endpoint
... you have security in Jetty, Tomcat, etc.

<AlexPassant> http://arc.semsol.org/docs/v2/sparql+

AlexPassant: there are some differences in ARC2, which is sparql+

AlexPassant summarizes

AlexPassant: the main difference is INSERT DATA and DELETE DATA

<AlexPassant> SPARQL+ supports LOAD, INSERT, DELETE

<AlexPassant> no DROP (but DELETE GRAPH), no CLEAR, no CREATE

AlexPassant: it does only HTTP POST

<AlexPassant> API key for updates via HTTP POST

<SimonS> like Eric's INSERT GRAPH patterns

<pgearon> http://mulgara.org/trac/wiki/TQLUserGuide

<ericP> SPARQLfed

<AxelPolleres> mulgara has transactions

AndyS: we had some transaction stuff, but we took it out

<Zakim> ericP, you wanted to talk describe grammar differences

<ericP> SPARUL à la ericP

LeeF: what would you get back?

AndyS: ask yourself: What would HTTP do?
... you get a response code?

s/\?//

<LeeF> SPARQL/Update: HTTP response code: 200 + # of triples touched (try to avoid touching anywhere from 1 - 399 triples)

<Zakim> LeeF, you wanted to ask about 'return values'

<AxelPolleres> * concurrency issues?

<AxelPolleres> * securtity mechanisms

<AxelPolleres> * empty graphs vs. quad-stores

<AxelPolleres> more update operations?

<AxelPolleres> * protocol issue? HTTP PUT/POST, SOAP, content negotiation/switch for mediatype?

<AxelPolleres> * issue: MODIFY deletes and inserts all graphs?

<AxelPolleres> * move data between graphs (select on one graph and insert into another... copy from/to)

<ericP> SPARULfed example: INSERT { GRAPH <foo> { ?x foaf:know ?y . ?y foaf:knows ?x } } BINDINGS (?x ?y) { (<bob> <sue>) (<mary> <jane>) }

<AxelPolleres> * dynamic graph (variable) for graph to update/modify

<AxelPolleres> * conjunction of operation vs atomocity, transactions

AndyS: what is the problem being solved?

<Zakim> pgearon, you wanted to comment on commonality between proposals

AndyS: a minimal solution is to delete and insert triples in an existing graph

pgearon: all proposals come up with very similar ideas

<AxelPolleres> * minimal (delete, insert triples only )vs fully-fledged solution

<LeeF> SPARQL/Update: The Lemmings Edition?

pgearon: the basic functionality is pretty much the same

AndyS: what worries me is the lack of things that calls it into question, are we charging in perfect harmony over the edge of a cliff?

<LeeF> It sounds to me like we need some explicit use case gathering here.

<LeeF> Note that http://www.w3.org/2009/sparql/wiki/Feature:Update#Use_cases is empty

AndyS: we should not jump directly to the solution

<pgearon> +1 for changesets

AndyS: timbl and talis have the notion of changesets, which is a bunch of things to remove and things to add

<pgearon> +q slight issue with changesets

AndyS: with a pattern you can change a lot with only few characters, changesets are deltas

<AxelPolleres> paul, you have to type "q+ to ..."

<AxelPolleres> does anybody have a link to changesets?

<LeeF> http://www.w3.org/DesignIssues/Diff type of thing

<LeeF> (I imagine, don't have a link for how we do it in Anzo)

<SimonS> http://www.openrdf.org/doc/sesame2/system/ch08.html

SimonS: it would be nice to have it update capability in the protocol _and_ a language

<Zakim> AndyS, you wanted to mention other approaches

<SimonS> DAV

<AxelPolleres> LeeF: Virtuoso does WebDAV

SteveH: has anyone done WebDAV?

<AlexPassant> http://docs.openlinksw.com/virtuoso/rdfinsertmethods.html#rdfinsertmethodwebdav

<Zakim> ericP, you wanted to suggest that principle motivations for bare-bones HTTP verbs would be for caching and safety

<AxelPolleres> ericP: HTTP directives solution nice for caching and safety?

SteveH: there is also the curl command line to easily do updates
... curl can simply PUT a file on your disc

<Zakim> pgearon, you wanted to note a slight issue with changesets

<Zakim> AxelPolleres, you wanted to ask about whether this is RDF/update rather than SPARQL/update

AxelPolleres: would this lightweight HTTP solution be SPARQL/Update

SteveH: it would be in the protocol

<AxelPolleres> discussion whether LOAD data is standard in SQL

+1 on both

<pgearon> +1 on both

<AxelPolleres> second attempt to collect issues:

<AxelPolleres> * minimal (delete, insert triples only, HTTP protocol) vs fully-fledged solution: PUT/DELETE only? vs. data manipulation language, DAV to SPARQL/Update

<AxelPolleres> * concurrency issues?

<AxelPolleres> * securtity mechanisms

<AxelPolleres> * empty graphs vs. quad-stores

<AxelPolleres> * more update operations?

<AxelPolleres> * protocol issue? HTTP PUT/POST, SOAP?

<AxelPolleres> * content negotiation/switch for mediatype?

<AxelPolleres> * issue: MODIFY deletes and inserts all graphs?

<AxelPolleres> * move data between graphs (select on one graph and insert into another... copy from/to)

<AxelPolleres> * dynamic graph (variable) for graph to update/modify

<AxelPolleres> * conjunction of operation vs atomocity, transactions

<AxelPolleres> * subqueries in Update operations, full expressivity

LeeF: points back to his post about who put Update on the top
... can those come up with use cases?

ericP: one use case is Tabulator
... the other is that people were asking about it and I said "RSN"

LukeWM: we implemented it to edit FOAF files

<AxelPolleres> we shall collect these use cases for update, ... in F&R?

<AlexPassant> AxelPolleres: +1

LukeWM: this takes advantage of patterns

<AxelPolleres> SteveH: does our use case need Modufy/update or only deletes an inserts?

<AlexPassant> ttp://esw.w3.org/topic/PushBackDataToLegacySourcesRDForms

AlexPassant: we have a web2.0 app where people edit their data

http://esw.w3.org/topic/PushBackDataToLegacySourcesRDForms

<AxelPolleres> ACTION: Alexandre to ask in DERI about whether RDF Forms/pushback uses WHERE in updates [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action14]

<trackbot> Created ACTION-27 - Ask in DERI about whether RDF Forms/pushback uses WHERE in updates [on Alexandre Passant - due 2009-05-14].

pgearon: we use it all the time

<AxelPolleres> AlexPAssant mentioned 3 use cases.

<AlexPassant> 1st one: integration of remote sources in a store (graph update only), 2nd personal data management (graph only afair - have to check) 3rd one: RDForms

<Zakim> KjetilK_Lap, you wanted to say we use it too

<AxelPolleres> paul: update of blanknodes neesds WHERE, becasue I can't reference them directly

<AxelPolleres> kjetil, can you summarize your use case on IRC yourself

KjetilK_Lap: we have applications where we use all features of SPARUL
... not a lot of CLEAR GRAPHs, if we need that we usually do it on the command line
... we have an interface where people enter data about resources with certain properties,

<AxelPolleres> AndyS: main use case provide users what they are used to from SQL for stores

KjetilK_Lap: of course if there is a new resource, we do INSERT DATA, but it is important to edit existing resources, and then WHERE becomes important
... I suppose it would be OK to have a HTTP DELETE to delete a graph instead of a CLEAR GRAPH, but now we do not use dereferencable URIs for graphs, since we haven't needed to do it, thus it would be harder to work with

<Zakim> AxelPolleres, you wanted to comment on interplay between update and entailment, relevant for us?

AxelPolleres: do we need to consider it in connection with entailment regimes?

<ericP> delete them harder?

AndyS: yeah, the case is "I've deleted my triples, but they are still there!"

<LeeF> DELETE FROM <g> WHERE { ?s rdf:type owl:Thing } --> remove everything!

<AndyS> Not classes.

<LeeF> oh dang, yeah

<LeeF> rdfs:Resource ?

<AndyS> Or axiomatic triples.

<AndyS> rdf:type rdf:type rdf:Property.

<LeeF> nothing i can do to make that no longer exist? :)

AndyS: what is the state-of-the-art with OWL?

<AxelPolleres> Birte: update implies do inference from scratch, typically.

<AndyS> Not as far as I know. MT has some other axiomatic triples.

bglimm: basically, you start with scratch, take what you have and do inference from scratch
... it is an active research area, but it is not clear how it should be done

<Zakim> LeeF, you wanted to ask how long SPARQL Update submission has been 'in the wild'

<AndyS> http://www.w3.org/TR/rdf-mt/#RDFINTERP : blue table

LeeF: how long has SPARUL been in the wild?

AndyS: there is one dated March 2007

<AndyS> Earlier than http://jena.hpl.hp.com/~afs/SPARQL-Update-v1.html

pgearon: it, or something like it has been in use for a while now

SteveH: SPARUL is technically older than SPARQL :-)

<LeeF> technical difficulties

iv_an_ru:

eh, no, the older

<LeeF> :)

AndyS: ivan was also pretty clear it should be a submission

LeeF: it has a lot of support and is being used, but can we make a good recommendation of this?

<iv_an_ru> SPARUL is worth and interoperable so the more "official" it is the better :)

AndyS: is there any way we can ping the community and get use cases?

LeeF: I think that we should do the more complex stuff and let the community do the simpler stuff

<LeeF> yesterday's word: megillah ~ today's word: kerfuffle

AxelPolleres: the SPARUL use cases should go into the F&R

<LukeWM> +1 to writing use cases down

AndyS: if we had a RESTy solution, would we get away with that?

ericP:

<Zakim> AxelPolleres, you wanted to speak about our use cases

ericP: how about we very early in the new charter publish a WD of SPARUL to bring out comments

<LeeF> let's give actions out! woo!

<LeeF> ACTION: ericP to provide tabulator update use case on wiki [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action15]

<trackbot> Sorry, couldn't find user - ericP

<LeeF> ACTION: eric to provide tabulator update use case on wiki [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action16]

<trackbot> Created ACTION-28 - Provide tabulator update use case on wiki [on Eric Prud'hommeaux - due 2009-05-14].

<LeeF> ACTION: Luke to provide FOAF update use case on wiki [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action17]

<trackbot> Created ACTION-29 - Provide FOAF update use case on wiki [on Luke Wilson-Mawer - due 2009-05-14].

<LeeF> ACTION: Alex to provide 3 uses cases on wiki [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action18]

<trackbot> Created ACTION-30 - Provide 3 uses cases on wiki [on Alexandre Passant - due 2009-05-14].

<LeeF> ACTION-30: err, update use cases

<trackbot> ACTION-30 Provide 3 uses cases on wiki notes added

<LeeF> ACTION: Paul to provide delete construct / insert construct based on blank nodes use case on wiki [recorded in http://www.w3.org/2009/05/07-sparql-minutes.html#action19]

<trackbot> Created ACTION-31 - Provide delete construct / insert construct based on blank nodes use case on wiki [on Paul Gearon - due 2009-05-14].

<AxelPolleres> * minimal (delete, insert triples only, HTTP protocol) vs fully-fledged solution: PUT/DELETE only? vs. data manipulation language, DAV to SPARQL/Update

<AxelPolleres> * concurrency issues?

<AxelPolleres> * securtity mechanisms

<AxelPolleres> * empty graphs vs. quad-stores

<AxelPolleres> * more update operations?

<AxelPolleres> * protocol issue? HTTP PUT/POST, SOAP?

<AxelPolleres> * content negotiation/switch for mediatype?

<AxelPolleres> * issue: MODIFY deletes and inserts all graphs?

<AxelPolleres> * move data between graphs (select on one graph and insert into another... copy from/to)

<AxelPolleres> * dynamic graph (variable) for graph to update/modify

<AxelPolleres> * conjunction of operation vs atomocity, transactions

<AxelPolleres> * subqueries in Update operations, full expressivity

<AxelPolleres> * what can be cut of from SPARQL/Update submission basis?

<AxelPolleres> * entailment vs. update?

<AxelPolleres> ISSUE: minimal vs fully-fledged update language

<trackbot> Created ISSUE-17 - Minimal vs fully-fledged update language ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/17/edit .

<AxelPolleres> ISSUE: cuncurrency in SPARQL/update

<trackbot> Created ISSUE-18 - Cuncurrency in SPARQL/update ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/18/edit .

<AlexPassant> Use-cases for Update to be recorded on the Wiki using http://www.w3.org/2009/sparql/wiki/Category:UpdateUseCases

<AxelPolleres> ISSUE: security issues on SPARQL/UPdate

<trackbot> Created ISSUE-19 - Security issues on SPARQL/UPdate ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/19/edit .

<AxelPolleres> ISSUE: graphs aware stores vs. quad stores for SPARQL/update (empty graphs)

<trackbot> Created ISSUE-20 - Graphs aware stores vs. quad stores for SPARQL/update (empty graphs) ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/20/edit .

<AxelPolleres> ISSUE: more complex update operations, e.g. CHANGE objects

<trackbot> Created ISSUE-21 - More complex update operations, e.g. CHANGE objects ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/21/edit .

<pgearon> +1 for not supporting SOAP

<AxelPolleres> ISSUE: support of SOAP in SPARQL/Update

<trackbot> Created ISSUE-22 - Support of SOAP in SPARQL/Update ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/22/edit .

<Zakim> AxelPolleres, you wanted to claim WSDL is useful :-)

<AxelPolleres> SteveH/Andy: WSDL2HTTP doesn't really make life easier

<AxelPolleres> ISSUE: content negotiation/switch for mediatype

<trackbot> Created ISSUE-23 - Content negotiation/switch for mediatype ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/23/edit .

<AxelPolleres> move data between graphs (select on one graph and insert into another... copy from/to)

<pgearon> "ferfufle"? Is that like a "kerfuffle"?

<AxelPolleres> ISSUE: move data between graphs (select on one graph and insert into another... copy from/to)

<trackbot> Created ISSUE-24 - Move data between graphs (select on one graph and insert into another... copy from/to) ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/24/edit .

<AxelPolleres> ISSUE: dynamic graph (variable) for INTO graph to update/modify

<trackbot> Created ISSUE-25 - Dynamic graph (variable) for INTO graph to update/modify ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/25/edit .

<AxelPolleres> ISSUE: conjunction of operation vs atomocity, transactions

<trackbot> Created ISSUE-26 - Conjunction of operation vs atomocity, transactions ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/26/edit .

<LeeF> ISSUE-25: pgearon describes this issue as "fraught"

<trackbot> ISSUE-25 Dynamic graph (variable) for INTO graph to update/modify notes added

<AxelPolleres> ISSUE: subqueries in Update operations, full expressivity

<trackbot> Created ISSUE-27 - Subqueries in Update operations, full expressivity ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/27/edit .

<AxelPolleres> ISSUE: entailment regimes vs. update?

<trackbot> Created ISSUE-28 - Entailment regimes vs. update? ; please complete additional details at http://www.w3.org/2009/sparql/track/issues/28/edit .

<AxelPolleres> LeeF: we should be aggressive on resolving ISSUES to progress

wrap-up

<AxelPolleres> LeeF: If people suggeste resolutions and nobody speaks up, we should go ahead and resolve issues. Suggest resolutions!

<Zakim> LeeF, you wanted to say a word about all these issues in general

<AxelPolleres> LeeF: draft charter based on first internal draft of F&R

internal?

<AxelPolleres> feedback on the two-site approach very positive.

<AxelPolleres> people from west coase couldn't participate.

<AxelPolleres> AndyS: task forces would be an interesting idea.

<LeeF> +1 to trying task forces out

<AxelPolleres> ... for parallelizable tasks. Telecons rather for coodrination

<AxelPolleres> SemTech: Alex, Lee, Eric, Paul

<AlexPassant> Ivan herman will also be there

<LeeF> Regrest for Tuesday: Axel, Alex, Simon (at risk)

<pgearon> AndyS: quick question for you......

- DRAFT -

SV_MEETING_TITLE

07 May 2009

Attendees

Contents

aggregates

SPARQL Update session

wrap-up

Summary of Action Items

Scribe.perl diagnostic output