def prettyquery_helper(query, tabs='', indent=' ', namespaces=n): """ return a pretty string of the query """ s = "" if isinstance(query, dict): if 'name' in query: s += "{Translation : " + str(query['name']) + "}" else: s += '{\n' prettykeys = [(prettyquery_helper(k, tabs + indent, indent), k) for k in query] for prettyk, k in sorted(prettykeys): s += tabs + indent + prettyk + ' : ' + prettyquery_helper( query[k], tabs + indent, indent) + ',\n' s += tabs + '}' elif isinstance(query, list): if len(query) == 0: s += '[]\n' else: prettylist = [ prettyquery_helper(i, tabs + indent, indent) for i in query ] if (len(query) <= 3 or sum(map(len, prettylist)) < 80) and any( ['\n' not in item for item in prettylist]): s += '[' for item in prettylist: s += ' ' + item + ',' s += ' ]\n' else: s += '[\n' for item in prettylist: s += tabs + indent + item + ',\n' s += tabs + ']\n' elif isinstance(query, tuple): # [:-1] cuts off the \n at the end s += '(%s)' % prettyquery_helper(list(query), tabs, indent, namespaces)[:-1] elif isinstance(query, set): s += 'set(%s)' % prettyquery_helper(list(query), tabs, indent, namespaces) elif isinstance(query, URIRef): return unicode(namespaces.shortenForN(query)) elif isinstance(query, Literal): if query.datatype == URIRef('http://www.w3.org/2001/XMLSchema#float') or \ query.datatype == URIRef('http://www.w3.org/2001/XMLSchema#int') : return unicode(query.toPython()) else: return repr(unicode(query)) elif is_any_var(query): return str(query) elif isinstance(query, types.FunctionType): return "<function %s>" % query.__name__ else: s += repr(query) return s
def prettyquery_helper(query, tabs="", indent=" ", namespaces=n): """ return a pretty string of the query """ s = "" if isinstance(query, dict): if "name" in query: s += "{Translation : " + str(query["name"]) + "}" else: s += "{\n" prettykeys = [(prettyquery_helper(k, tabs + indent, indent), k) for k in query] for prettyk, k in sorted(prettykeys): s += tabs + indent + prettyk + " : " + prettyquery_helper(query[k], tabs + indent, indent) + ",\n" s += tabs + "}" elif isinstance(query, list): if len(query) == 0: s += "[]\n" else: prettylist = [prettyquery_helper(i, tabs + indent, indent) for i in query] if (len(query) <= 3 or sum(map(len, prettylist)) < 80) and any(["\n" not in item for item in prettylist]): s += "[" for item in prettylist: s += " " + item + "," s += " ]\n" else: s += "[\n" for item in prettylist: s += tabs + indent + item + ",\n" s += tabs + "]\n" elif isinstance(query, tuple): # [:-1] cuts off the \n at the end s += "(%s)" % prettyquery_helper(list(query), tabs, indent, namespaces)[:-1] elif isinstance(query, set): s += "set(%s)" % prettyquery_helper(list(query), tabs, indent, namespaces) elif isinstance(query, URIRef): return unicode(namespaces.shortenForN(query)) elif isinstance(query, Literal): if query.datatype == URIRef("http://www.w3.org/2001/XMLSchema#float") or query.datatype == URIRef( "http://www.w3.org/2001/XMLSchema#int" ): return unicode(query.toPython()) else: return repr(unicode(query)) elif is_any_var(query): return str(query) elif isinstance(query, types.FunctionType): return "<function %s>" % query.__name__ else: s += repr(query) return s
def map_q_to_t(self, q_in_bs, t_to_q_in_b) : """ given bindings set in query space, and translation->query mapping, return bindings in translation_space """ t_in_bs = [] for q_in_b in q_in_bs : t_in_b = {} for var, value in t_to_q_in_b.iteritems() : if is_any_var(value) and value.name in q_in_b : t_in_b[var] = q_in_b[value.name] else : t_in_b[var] = t_to_q_in_b[var] t_in_bs.append(t_in_b) return t_in_bs
def write_sparql_delete(self, query, bindings_set=[{}]): """ delete triples from sparql database. NOTE: any URI which is_var will be converted to a fresh bnode URI """ if not self.sparql: raise Exception("sparql not initialized") query_triples = self.parser.parse(query) bindings_set = explode_bindings_set(bindings_set) for triples in sub_var_bindings_set(query_triples, bindings_set): # replace any kind of var with a 'standard' var for SimpleSPARQL for triple in triples: for i, v in enumerate(triple): if is_any_var(v): triple[i] = Var(v.name) self.sparql.delete(triples)
def write_sparql_delete(self, query, bindings_set = [{}]) : """ delete triples from sparql database. NOTE: any URI which is_var will be converted to a fresh bnode URI """ if not self.sparql : raise Exception("sparql not initialized") query_triples = self.parser.parse(query) bindings_set = explode_bindings_set(bindings_set) for triples in sub_var_bindings_set(query_triples, bindings_set) : # replace any kind of var with a 'standard' var for SimpleSPARQL for triple in triples : for i, v in enumerate(triple) : if is_any_var(v) : triple[i] = Var(v.name) self.sparql.delete(triples)
def check_for_inconsistent_var_litvar(self, triples) : """ check to see if a var is a Var in one place and a LitVar in another """ # var_types := {var_name : var} # is populated as we iterate over all of the values. any vars we find are # added to var_types so we can make sure that other vars of the same name # have the same type var_types = {} for triple in triples : for v in triple : if is_any_var(v) : if v.name in var_types : if var_types[v.name] != type(v) : t1 = str(type(v)) raise Exception("inconsistent var type. %s and %s" % ( var_type_name(v), var_type_name(var_types[v.name]) )) else : var_types[v.name] = type(v)
def check_for_inconsistent_var_litvar(self, triples): """ check to see if a var is a Var in one place and a LitVar in another """ # var_types := {var_name : var} # is populated as we iterate over all of the values. any vars we find are # added to var_types so we can make sure that other vars of the same name # have the same type var_types = {} for triple in triples: for v in triple: if is_any_var(v): if v.name in var_types: if var_types[v.name] != type(v): t1 = str(type(v)) raise Exception( "inconsistent var type. %s and %s" % (var_type_name(v), var_type_name(var_types[v.name]))) else: var_types[v.name] = type(v)
def map_t_to_q(self, t_out_b, t_to_q_out_b, t_in_b={}) : """ given a bindings in translation space, and a translation->query mapping, return bindings in query space NOTE: t_in_b is only for generating warnings when a variable is in t_out_b but there is no bindings """ q_out_b = {} for var, value in t_out_b.iteritems() : if var in t_to_q_out_b : if is_any_var(t_to_q_out_b[var]) : q_out_b[t_to_q_out_b[var].name] = value else : assert t_to_q_out_b[var] == value q_out_b[var] = value else : # should there be a way to turn this off? if self.warnings : if var not in t_in_b : print 'warning: unused result "%s"' % var return q_out_b
def new_read(self, query, expected_vars = [], varnamespace = None, outvarnamespace = None) : #print('query',query) # TODO: extract out the result bindings as in self.read # TODO: allow object notation as root query. # TODO: depricate read, and others # TODO: more cleaning # TODO: figure out some way to avoid having resets everywhere. Should this # be some other class to do each translation? if varnamespace == None : varnamespace = self.n.var # for now, these need to come in the triples set in the same order as # required by SPARQL. LIMIT after ORDER and OFFSET after LIMIT modifiers = [] new_query = [] count = False for triple in query : modified = False if triple[0] == self.n.query.query : if triple[1] == self.n.query.limit : modifiers.append('LIMIT %d' % int(triple[2])) modified = True if triple[1] == self.n.query.offset : modifiers.append('OFFSET %d' % int(triple[2])) modified = True if triple[1] == self.n.query.sort_ascending : modifiers.append('ORDER BY ?%s' % var_name(triple[2])) modified = True if triple[1] == self.n.query.sort_descending : modifiers.append('ORDER BY DESC(?%s)' % var_name(triple[2])) modified = True if triple[1] == self.n.query['count'] : count = triple[2] if not is_any_var(count) : raise Exception('When query.query[query.count] = count. count must be a variable') count = var_name(count) modified = True if not modified : new_query.append(triple) query = new_query # determine what the output vars are before they are sanitized for # triplelist_to_sparql if count : output_vars_list = 'COUNT(*)' else : output_vars_list = '*' if outvarnamespace : output_vars = find_vars(query, lambda var: var.find(outvarnamespace) == 0) if len(output_vars) : output_vars_list = ' '.join(map(lambda x:'?'+x, output_vars)) self.sanitize_vars(query, outvarnamespace, varnamespace) else : print("couldn't find them") #print('output_vars_list',output_vars_list) self.reset_py_to_SPARQL_bnode() self._reset_SPARQL_variables() query_str = self.triplelist_to_sparql(query, varnamespace) #print('query',query) query = "SELECT %s WHERE { %s } %s" % (output_vars_list, self.wrapGraph(query_str), '\n'.join(modifiers)) ret = self.doQuery(query) if count : # NOTE: This is most likely implementation dependant. Works for Joseki-3.3.0 yield {count : int(ret['results']['bindings'][0][u'.1']['value'])} else : for binding in ret['results']['bindings'] : newbinding = {} for var, value in binding.iteritems() : if value['type'] == 'typed-literal' : if value['datatype'] == 'http://www.w3.org/2001/XMLSchema#integer' : newbinding[var] = int(value['value']) elif value['datatype'] == 'http://www.w3.org/2001/XMLSchema#decimal' : newbinding[var] = float(value['value']) elif value['type'] == 'literal' : newbinding[var] = value['value'] elif value['type'] == 'uri' : newbinding[var] = URIRef(value['value']) elif value['type'] == 'bnode' : raise Exception('cant do bnodes') yield newbinding