def _prepare_delete_many_query(resources, context, inverse=False):
query = delete()
if context:
query.from_(context)
query.template(("?s", "?p", "?o"))
if context:
where_clause = NamedGroup(context)
else:
where_clause = Group()
subjects = [resource.subject for resource in resources]
filter = " OR ".join(
[u"?s = <{0:s}>".format(subject) for subject in subjects])
filter = Filter("(%s)" % filter)
if inverse:
filter2 = " OR ".join(
[u"?o = <{0:s}>".format(subject) for subject in subjects])
filter2 = Filter("(%s)" % filter2)
where1 = Group([("?s", "?p", "?o"), filter])
where2 = Group([("?s", "?p", "?o"), filter2])
where_clause.append(Union([where1, where2]))
else:
where_clause.append(("?s", "?p", "?o"))
where_clause.append(filter)
query.where(where_clause)
return query
def _apply_solution_modifiers(params, query):
"""
Apply limit, offset, order parameters to query.
"""
if "limit" in params:
query.limit(params["limit"])
if "offset" in params:
query.offset(params["offset"])
if "get_by" in params:
def order_terms(s, p, o):
return (s, p, o) if direct else (o, p, s)
for attribute, values, direct in params["get_by"]:
if not isinstance(values, basestring) and hasattr(
values, "__iter__"):
where_clause = Union()
for value in values:
where_clause.append(order_terms("?s", attribute, value))
else:
where_clause = order_terms("?s", attribute, values)
query.where(where_clause)
if "filter" in params:
filter_idx = 0
for attribute, value, direct in params["filter"]:
filter_idx += 1
filter_variable = "?f%d" % filter_idx
query.where(("?s", attribute, filter_variable))
query.filter(value % filter_variable)
if "order" in params:
if params["order"]:
# Order by subject URI
if "desc" in params and params["desc"]:
query.order_by("DESC(?s)")
else:
query.order_by("?s")
else:
# Match another variable, order by it
query.optional_group(("?s", params["order"], "?o"))
if "desc" in params and params["desc"]:
query.order_by("DESC(?o)")
else:
query.order_by("?o")
return query
def __apply_limit_offset_order_get_by_filter(self, params, query):
""" Apply limit, offset, order parameters to query. """
if "limit" in params:
query.limit(params["limit"])
if "offset" in params:
query.offset(params["offset"])
if "get_by" in params:
for attribute, values, direct in params["get_by"]:
if direct:
order_terms = lambda a, b, c: (a, b, c)
else:
order_terms = lambda a, b, c: (c, b, a)
if hasattr(values, "__iter__"):
where_clause = Union()
for value in values:
where_clause.append(order_terms(
"?s", attribute, value))
else:
where_clause = order_terms("?s", attribute, values)
query.where(where_clause)
if "filter" in params:
filter_idx = 0
for attribute, value, direct in params["filter"]:
filter_idx += 1
filter_variable = "?f%d" % filter_idx
query.where(("?s", attribute, filter_variable))
query.filter(value % filter_variable)
if "order" in params:
if params["order"] == True:
# Order by subject URI
if "desc" in params and params["desc"]:
query.order_by("DESC(?s)")
else:
query.order_by("?s")
else:
# Match another variable, order by it
query.optional_group(("?s", params["order"], "?o"))
if "desc" in params and params["desc"]:
query.order_by("DESC(?o)")
else:
query.order_by("?o")
return query
def __build_where_clause(cls, q_obj, edge_iterator):
clauses = []
for child in q_obj.children:
if isinstance(child, Q):
subclauses = cls.__build_where_clause(child, edge_iterator)
connection = child.connection
else:
subclauses = cls.__build_attribute_clause(child, edge_iterator)
connection = Q.AND
if len(subclauses) > 1:
if connection == Q.AND:
clause = Group(subclauses)
elif connection == Q.OR:
clause = Union(subclauses)
else:
clause = subclauses[0]
clauses.append(clause)
return clauses
def __apply_limit_offset_order_get_by_filter(self, params, query):
""" Apply limit, offset, order parameters to query. """
def order_terms(a, b, c, direct):
if direct:
return (a, b, c)
else:
return (c, b, a)
if "limit" in params:
query.limit(params["limit"])
if "offset" in params:
query.offset(params["offset"])
if "get_by" in params:
edges = self.__edge_iterator()
clauses = self.__build_where_clause(params["get_by"], edges)
if params["get_by"].connection == Q.OR:
query.where(Union(clauses))
else:
query.where(*clauses)
if "filter" in params:
filter_idx = 0
for attribute, value, direct in params["filter"]:
filter_idx += 1
filter_variable = "?f%d" % filter_idx
query.where(("?s", attribute, filter_variable))
query.filter(value % filter_variable)
if "order" in params:
if params["order"] == True:
# Order by subject URI
if "desc" in params and params["desc"]:
query.order_by("DESC(?s)")
else:
query.order_by("?s")
elif params["order"] != False:
# Match another variable, order by it
edges = params["order"]
edge_idx = 0
last_edge = "?s"
where_clauses = []
# Build path to attribute, value pair for which we sort
for attribute, direct in edges:
edge_idx += 1
edge_variable = "?o%d" % edge_idx
where_clauses.append(order_terms(last_edge,
attribute,
edge_variable,
direct))
last_edge = edge_variable
query.optional_group(*where_clauses)
if "desc" in params and params["desc"]:
query.order_by("DESC(%s)" % last_edge)
else:
query.order_by(last_edge)
return query
class RDFQueryReader(RDFReader):
""" Super class for SuRF Reader plugins that wrap queryable `stores`. """
def __init__(self, *args, **kwargs):
RDFReader.__init__(self, *args, **kwargs)
self.use_subqueries = kwargs.get('use_subqueries', False)
if type(self.use_subqueries) in [str, tuple]:
self.use_subqueries = (self.use_subqueries.lower() == 'true')
elif type(self.use_subqueries) is not bool:
raise ValueError('The use_subqueries parameter must be a bool or a string set to "true" or "false"')
#protected interface
def _get(self, subject, attribute, direct, query_contexts):
query = query_SP(subject, attribute, direct, query_contexts)
result = self._execute(query)
return self.convert(result, 'v', 'g', 'c')
def _load(self, subject, direct, query_contexts):
query = query_S(subject, direct, query_contexts)
result = self._execute(query)
return self.convert(result, 'p', 'v', 'g', 'c')
def _is_present(self, subject, query_contexts):
query = query_Ask(subject, query_contexts)
result = self._execute(query)
return self._ask(result)
def _concept(self, subject):
query = query_Concept(subject)
result = self._execute(query)
return self.convert(result, 'c')
def _instances_by_attribute(self, concept, attributes, direct, context):
query = query_P_S(concept, attributes, direct, context)
result = self._execute(query)
return self.convert(result, 's', 'g', 'c')
@classmethod
def __edge_iterator(cls, edge='e'):
edge_idx = 0
while True:
yield '?' + edge + str(edge_idx)
edge_idx += 1
@classmethod
def __build_attribute_clause(cls, (edges, values), edge_iterator):
def order_terms(a, b, c, direct):
if direct:
return (a, b, c)
else:
return (c, b, a)
last_edge = "?s"
clauses = []
# Build path to attribute, value pair
for attribute, direct in edges[:-1]:
edge_variable = edge_iterator.next()
clauses.append(order_terms(last_edge,
attribute,
edge_variable,
direct))
last_edge = edge_variable
# Attach value query to path
attribute, direct = edges[-1]
if hasattr(values, "__iter__"):
union_clause = Union()
for value in values:
union_clause.append(order_terms(last_edge,
attribute,
value,
direct))
clauses.append(union_clause)
else:
clauses.append(order_terms(last_edge,
attribute,
values,
direct))
return clauses