def update(self, row, aggregator):
try:
if self.value is None:
self.value = _eval(self.expr, row)
else:
# self.compare is implemented by Minimum/Maximum
self.value = self.compare(self.value, _eval(self.expr, row))
# skip UNDEF or BNode => SPARQLTypeError
except NotBoundError:
pass
except SPARQLTypeError:
pass
def update(self, row, aggregator):
try:
if self.value is None:
self.value = _eval(self.expr, row)
else:
# self.compare is implemented by Minimum/Maximum
self.value = self.compare(self.value, _eval(self.expr, row))
# skip UNDEF or BNode => SPARQLTypeError
except NotBoundError:
pass
except SPARQLTypeError:
pass
def agg_Count(a, group, bindings):
c = 0
for x in group:
try:
if a.vars != '*':
_eval(a.vars, x)
c += 1
except:
return # error in aggregate => no binding
# pass # simply dont count
bindings[a.res] = Literal(c)
def agg_Count(a, group, bindings):
c = 0
for x in group:
try:
if a.vars != '*':
_eval(a.vars, x)
c += 1
except:
return # error in aggregate => no binding
# pass # simply dont count
bindings[a.res] = Literal(c)
def agg_Avg(a, group, bindings):
c = 0
s = 0
dt = None
for x in group:
try:
e = _eval(a.vars, x)
n = numeric(e)
if dt == None:
dt = e.datatype
else:
dt = type_promotion(dt, e.datatype)
if type(s) == float and type(n) == Decimal:
s += float(n)
elif type(n) == float and type(s) == Decimal:
s = float(s) + n
else:
s += n
c += 1
except:
return # error in aggregate => no binding
if c == 0:
bindings[a.res] = Literal(0)
if dt == XSD.float or dt == XSD.double:
bindings[a.res] = Literal(s / c)
else:
bindings[a.res] = Literal(Decimal(s) / Decimal(c))
def agg_Sample(a, group, bindings):
for ctx in group:
try:
bindings[a.res] = _eval(a.vars, ctx)
break
except NotBoundError:
pass
def evalAggregateJoin(ctx, agg):
# import pdb ; pdb.set_trace()
p = evalPart(ctx, agg.p)
# p is always a Group, we always get a dict back
group_expr = agg.p.expr
res = collections.defaultdict(lambda: Aggregator(aggregations=agg.A))
if group_expr is None:
# no grouping, just COUNT in SELECT clause
# get 1 aggregator for counting
aggregator = res[True]
for row in p:
aggregator.update(row)
else:
for row in p:
# determine right group aggregator for row
k = tuple(_eval(e, row, False) for e in group_expr)
res[k].update(row)
# all rows are done; yield aggregated values
for aggregator in itervalues(res):
yield FrozenBindings(ctx, aggregator.get_bindings())
# there were no matches
if len(res) == 0:
yield FrozenBindings(ctx)
def agg_Avg(a, group, bindings):
c = 0
s = 0
dt = None
for x in group:
try:
e = _eval(a.vars, x)
n = numeric(e)
if dt == None:
dt = e.datatype
else:
dt = type_promotion(dt, e.datatype)
if type(s) == float and type(n) == Decimal:
s += float(n)
elif type(n) == float and type(s) == Decimal:
s = float(s) + n
else:
s += n
c += 1
except:
return # error in aggregate => no binding
if c == 0:
bindings[a.res] = Literal(0)
if dt == XSD.float or dt == XSD.double:
bindings[a.res] = Literal(s / c)
else:
bindings[a.res] = Literal(Decimal(s) / Decimal(c))
def evalAggregateJoin(ctx, agg):
# import pdb ; pdb.set_trace()
p = evalPart(ctx, agg.p)
# p is always a Group, we always get a dict back
group_expr = agg.p.expr
res = collections.defaultdict(lambda: Aggregator(aggregations=agg.A))
if group_expr is None:
# no grouping, just COUNT in SELECT clause
# get 1 aggregator for counting
aggregator = res[True]
for row in p:
aggregator.update(row)
else:
for row in p:
# determine right group aggregator for row
k = tuple(_eval(e, row, False) for e in group_expr)
res[k].update(row)
# all rows are done; yield aggregated values
for aggregator in itervalues(res):
yield FrozenBindings(ctx, aggregator.get_bindings())
# there were no matches
if len(res) == 0:
yield FrozenBindings(ctx)
def update(self, row, aggregator):
try:
# set the value now
aggregator.bindings[self.var] = _eval(self.expr, row)
# and skip this accumulator for future rows
del aggregator.accumulators[self.var]
except NotBoundError:
pass
def update(self, row, aggregator):
try:
# set the value now
aggregator.bindings[self.var] = _eval(self.expr, row)
# and skip this accumulator for future rows
del aggregator.accumulators[self.var]
except NotBoundError:
pass
def update(self, row, aggregator):
try:
value = _eval(self.expr, row)
self.value.append(value)
if self.distinct:
self.seen.add(value)
# skip UNDEF
except NotBoundError:
pass
def update(self, row, aggregator):
try:
value = _eval(self.expr, row)
self.value.append(value)
if self.distinct:
self.seen.add(value)
# skip UNDEF
except NotBoundError:
pass
def _eval_rows(expr, group, distinct):
seen = set()
for row in group:
try:
val = _eval(expr, row)
if not distinct or not val in seen:
yield val
seen.add(val)
except:
pass
def evalExtend(ctx, extend):
# TODO: Deal with dict returned from evalPart from GROUP BY
for c in evalPart(ctx, extend.p):
try:
e = _eval(extend.expr, c.forget(ctx))
if isinstance(e, SPARQLError):
raise e
yield c.merge({extend.var: e})
except SPARQLError:
yield c
def evalExtend(ctx, extend):
# TODO: Deal with dict returned from evalPart from GROUP BY
for c in evalPart(ctx, extend.p):
try:
e = _eval(extend.expr, c.forget(ctx))
if isinstance(e, SPARQLError):
raise e
yield c.merge({extend.var: e})
except SPARQLError:
yield c
def evalGroup(ctx, group):
"""
http://www.w3.org/TR/sparql11-query/#defn_algGroup
"""
p = evalPart(ctx, group.p)
if not group.expr:
return {1: list(p)}
else:
res = collections.defaultdict(list)
for c in p:
k = tuple(_eval(e, c, False) for e in group.expr)
res[k].append(c)
return res
def update(self, row, aggregator):
try:
value = _eval(self.expr, row)
dt = self.datatype
if dt is None:
dt = value.datatype
else:
dt = type_promotion(dt, value.datatype)
self.datatype = dt
self.value = sum(type_safe_numbers(self.value, numeric(value)))
if self.distinct:
self.seen.add(value)
except NotBoundError:
# skip UNDEF
pass
def agg_Max(a, group, bindings):
m = None
for x in group:
try:
v = numeric(_eval(a.vars, x))
if m is None:
m = v
else:
m = num_max(v, m)
except:
return # error in aggregate => no binding
if m is not None:
bindings[a.res] = Literal(m)
def update(self, row, aggregator):
try:
value = _eval(self.expr, row)
dt = self.datatype
if dt is None:
dt = value.datatype
else:
dt = type_promotion(dt, value.datatype)
self.datatype = dt
self.value = sum(type_safe_numbers(self.value, numeric(value)))
if self.distinct:
self.seen.add(value)
except NotBoundError:
# skip UNDEF
pass
def evalGroup(ctx, group):
"""
http://www.w3.org/TR/sparql11-query/#defn_algGroup
"""
p = evalPart(ctx, group.p)
if not group.expr:
return {1: list(p)}
else:
res = collections.defaultdict(list)
for c in p:
k = tuple(_eval(e, c) for e in group.expr)
res[k].append(c)
return res
def agg_Count(a, group, bindings):
c = 0
for x in group:
try:
if a.vars != '*':
val = _eval(a.vars, x)
if isinstance(val, NotBoundError):
continue
c += 1
except:
return # error in aggregate => no binding
# pass # simply dont count
bindings[a.res] = Literal(c)
def agg_Count(a, group, bindings):
c = 0
for x in group:
try:
if a.vars != '*':
val = _eval(a.vars, x)
if isinstance(val, NotBoundError):
continue
c += 1
except:
return # error in aggregate => no binding
# pass # simply dont count
bindings[a.res] = Literal(c)
def agg_Max(a, group, bindings):
m = None
for x in group:
try:
v = numeric(_eval(a.vars, x))
if m is None:
m = v
else:
m = num_max(v, m)
except:
return # error in aggregate => no binding
if m is not None:
bindings[a.res] = Literal(m)
def update(self, row, aggregator):
try:
value = _eval(self.expr, row)
dt = self.datatype
self.sum = sum(type_safe_numbers(self.sum, numeric(value)))
if dt is None:
dt = value.datatype
else:
dt = type_promotion(dt, value.datatype)
self.datatype = dt
if self.distinct:
self.seen.add(value)
self.counter += 1
# skip UNDEF or BNode => SPARQLTypeError
except NotBoundError:
pass
except SPARQLTypeError:
pass
def update(self, row, aggregator):
try:
value = _eval(self.expr, row)
dt = self.datatype
self.sum = sum(type_safe_numbers(self.sum, numeric(value)))
if dt is None:
dt = value.datatype
else:
dt = type_promotion(dt, value.datatype)
self.datatype = dt
if self.distinct:
self.seen.add(value)
self.counter += 1
# skip UNDEF or BNode => SPARQLTypeError
except NotBoundError:
pass
except SPARQLTypeError:
pass
def agg_Sum(a, group, bindings):
c = 0
dt = None
for x in group:
try:
e = _eval(a.vars, x)
n = numeric(e)
if dt == None:
dt = e.datatype
else:
dt = type_promotion(dt, e.datatype)
if type(c) == float and type(n) == Decimal:
c += float(n)
elif type(n) == float and type(c) == Decimal:
c = float(c) + n
else:
c += n
except:
pass # simply dont count
bindings[a.res] = Literal(c, datatype=dt)
def agg_Sum(a, group, bindings):
c = 0
dt = None
for x in group:
try:
e = _eval(a.vars, x)
n = numeric(e)
if dt == None:
dt = e.datatype
else:
dt = type_promotion(dt, e.datatype)
if type(c) == float and type(n) == Decimal:
c += float(n)
elif type(n) == float and type(c) == Decimal:
c = float(c) + n
else:
c += n
except:
pass # simply dont count
bindings[a.res] = Literal(c, datatype=dt)
def agg_Sample(a, group, bindings):
try:
bindings[a.res] = _eval(a.vars, next(iter(group)))
except StopIteration:
pass # no res
def agg_Sample(a, group, bindings):
for ctx in group:
val = _eval(a.vars, ctx)
if not isinstance(val, NotBoundError):
bindings[a.res] = val
break
def _eval_rows(expr, group):
for row in group:
try:
yield _eval(expr, row)
except:
pass
def eval_row(self, row):
return _eval(self.expr, row)
def use_row(self, row):
"""tests distinct with set"""
return _eval(self.expr, row) not in self.seen
def use_row(self, row):
"""tests distinct with set """
return _eval(self.expr, row) not in self.seen
def eval_row(self, row):
return _eval(self.expr, row)
def agg_Sample(a, group, bindings):
try:
bindings[a.res] = _eval(a.vars, next(iter(group)))
except StopIteration:
pass # no res
def agg_Sample(a, group, bindings):
for ctx in group:
val = _eval(a.vars, ctx)
if not isinstance(val, NotBoundError):
bindings[a.res] = val
break
def _eval_rows(expr, group):
for row in group:
try:
yield _eval(expr, row)
except:
pass
