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