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
