def read_sparql(self, query, bindings_set = [{}], keep_old_bindings = False) : """ read from the sparql database @arg query the query in one long string, a list of string or triples_set @arg bindings_set is a set of bindings to apply on the way in @arg keep_old_bindings if True will keep variable bound in the incoming bindings_set in the new bindings_set @return a new set of bindings """ if not self.sparql : raise Exception("sparql not initialized") results = [] query_triples = self.parser.parse(query) #p('query_triples',query_triples) #for triples in sub_var_bindings_set(query_triples, bindings_set) : for bindings in explode_bindings_set(bindings_set) : triples = sub_var_bindings(query_triples, bindings) #self.sanitize_vars(triples) read_bindings_set = self.sparql.read(triples, outvarnamespace = LitVar) if keep_old_bindings : #p('bindings',bindings) #p('read_bindings_set',read_bindings_set) for read_bindings in read_bindings_set : new_bindings = copy.copy(bindings) new_bindings.update(read_bindings) results.append(new_bindings) else : results.extend(read_bindings_set) return results
def read_sparql(self, query, bindings_set=[{}], keep_old_bindings=False): """ read from the sparql database @arg query the query in one long string, a list of string or triples_set @arg bindings_set is a set of bindings to apply on the way in @arg keep_old_bindings if True will keep variable bound in the incoming bindings_set in the new bindings_set @return a new set of bindings """ if not self.sparql: raise Exception("sparql not initialized") results = [] query_triples = self.parser.parse(query) #p('query_triples',query_triples) #for triples in sub_var_bindings_set(query_triples, bindings_set) : for bindings in explode_bindings_set(bindings_set): triples = sub_var_bindings(query_triples, bindings) #self.sanitize_vars(triples) read_bindings_set = self.sparql.read(triples, outvarnamespace=LitVar) if keep_old_bindings: #p('bindings',bindings) #p('read_bindings_set',read_bindings_set) for read_bindings in read_bindings_set: new_bindings = copy.copy(bindings) new_bindings.update(read_bindings) results.append(new_bindings) else: results.extend(read_bindings_set) return results
def python(self, query, bindings_set=[{}]): new_bindings_set = [] for bindings in bindings_set: # TODO don't allow people to break in! Not sure how good this is ... bindings['__builtins__'] = None bindings['bindings'] = bindings bindings['str'] = str exec query in bindings del bindings['__builtins__'] del bindings['bindings'] del bindings['str'] new_bindings_set.extend(explode_bindings_set(bindings)) return new_bindings_set
def python(self, query, bindings_set = [{}]) : new_bindings_set = [] for bindings in bindings_set : # TODO don't allow people to break in! Not sure how good this is ... bindings['__builtins__'] = None bindings['bindings'] = bindings bindings['str'] = str exec query in bindings del bindings['__builtins__'] del bindings['bindings'] del bindings['str'] new_bindings_set.extend(explode_bindings_set(bindings)) return new_bindings_set
def read_translate(self, query, bindings_set=[{}], reqd_bound_vars=[]): query_triples = self.parser.parse(query) ret_evals = [] bindings_set = explode_bindings_set(bindings_set) if len(reqd_bound_vars) == 0: reqd_bound_vars = find_vars(query_triples, is_lit_var) if len(reqd_bound_vars) == 0: p('Warning: no required bound variables. Are there any _vars?' ) #for triples in sub_var_bindings_set(query_triples, bindings_set) : for bindings in bindings_set: #p('bindings',bindings) #p('reqd_bound_vars',reqd_bound_vars) new_reqd_bound_vars = [] provided_bindings = [] for var in reqd_bound_vars: if var in bindings: provided_bindings.append(var) else: new_reqd_bound_vars.append(var) reqd_bound_vars = new_reqd_bound_vars #p('reqd_bound_vars',reqd_bound_vars) #p('provided_bindings',provided_bindings) triples = sub_var_bindings(query_triples, bindings) begin_compile = time.time() ret_comp = self.compiler.compile(triples, reqd_bound_vars) end_compile = time.time() #p('ret_comp',ret_comp) if 'time' in self.options: print 'compile time:', end_compile - begin_compile self.cum_comp_time += end_compile - begin_compile if ret_comp == False: raise CompilerException( "Couldn't compile ... sorry I don't have more here") begin_eval = time.time() #for i in range(100) : ret_eval = self.evaluator.evaluate(ret_comp) end_eval = time.time() if 'time' in self.options: print 'eval time:', end_eval - begin_eval self.cum_eval_time += end_eval - begin_eval for ret in ret_eval: for var in provided_bindings: ret[var] = bindings[var] #p('ret_eval',ret_eval) ret_evals.extend(ret_eval) return ret_evals
def read_translate(self, query, bindings_set = [{}], reqd_bound_vars = []) : query_triples = self.parser.parse(query) ret_evals = [] bindings_set = explode_bindings_set(bindings_set) if len(reqd_bound_vars) == 0 : reqd_bound_vars = find_vars(query_triples, is_lit_var) if len(reqd_bound_vars) == 0 : p('Warning: no required bound variables. Are there any _vars?') #for triples in sub_var_bindings_set(query_triples, bindings_set) : for bindings in bindings_set : #p('bindings',bindings) #p('reqd_bound_vars',reqd_bound_vars) new_reqd_bound_vars = [] provided_bindings = [] for var in reqd_bound_vars : if var in bindings : provided_bindings.append(var) else : new_reqd_bound_vars.append(var) reqd_bound_vars = new_reqd_bound_vars #p('reqd_bound_vars',reqd_bound_vars) #p('provided_bindings',provided_bindings) triples = sub_var_bindings(query_triples, bindings) begin_compile = time.time() ret_comp = self.compiler.compile(triples, reqd_bound_vars) end_compile = time.time() #p('ret_comp',ret_comp) if 'time' in self.options : print 'compile time:',end_compile-begin_compile self.cum_comp_time += end_compile-begin_compile if ret_comp == False : raise CompilerException("Couldn't compile ... sorry I don't have more here") begin_eval = time.time() #for i in range(100) : ret_eval = self.evaluator.evaluate(ret_comp) end_eval = time.time() if 'time' in self.options : print 'eval time:',end_eval-begin_eval self.cum_eval_time += end_eval-begin_eval for ret in ret_eval : for var in provided_bindings : ret[var] = bindings[var] #p('ret_eval',ret_eval) ret_evals.extend(ret_eval) return ret_evals
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 write_sparql(self, query, bindings_set = [{}]) : """ write triples into 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 bindings in bindings_set : triples = sub_var_bindings(query_triples, bindings) missing_vars = find_vars(triples) if len(missing_vars) is not 0 : new_bindings = dict([(var, self.urigen()) for var in missing_vars]) triples = sub_var_bindings(triples, new_bindings) bindings.update(new_bindings) self.sparql.write(triples) return bindings_set
def write_sparql(self, query, bindings_set=[{}]): """ write triples into 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 bindings in bindings_set: triples = sub_var_bindings(query_triples, bindings) missing_vars = find_vars(triples) if len(missing_vars) is not 0: new_bindings = dict([(var, self.urigen()) for var in missing_vars]) triples = sub_var_bindings(triples, new_bindings) bindings.update(new_bindings) self.sparql.write(triples) return bindings_set
def evaluate_step_with_bindings_set(self, step, q_in_bs) : """ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !! the trick here I think is that I am trying to reuse code between !! function and multifunction cases that aren't the same. Its hard to !! make the code more complex and repetitive at this point, but I think !! there are bugs in the code as it is now due to its false simplicity !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! """ # descriptions of variables # q_in_bs : query space to value # t_to_q_in_b : translation to query space # t_in_bs : translation space to value # t_out_bs : translation space to value # t_to_q_out_b : translation to query space # q_out_bs : query space to value t_to_q_in_b = step['input_bindings'] t_to_q_out_b = step['output_bindings'] t_in_bs = self.map_q_to_t(q_in_bs, t_to_q_in_b) # NOTE that if t_out_b == [] aka. the input binding set is no longer valid # we want that to be added to the ret, not the input bindings if 'function' in step['translation'] : q_out_bs = [] for t_in_b, q_in_b in izip(t_in_bs, q_in_bs) : t_out_b = step['translation']['function'](t_in_b) if t_out_b == None : t_out_b = t_in_b self.t_out_b_valid(step, t_out_b, t_to_q_out_b) for t_out_b in self.flatten(t_out_b) : # need to make a copy so that we don't mess up code # somewhere else that expects to be able to use q_in_b later q_out_b = copy.copy(q_in_b) q_out_b.update(self.map_t_to_q(t_out_b, t_to_q_out_b, t_in_b)) q_out_bs.append(q_out_b) elif 'multi_function' in step['translation'] : # a multi_function takes in the entire t_in_bs and returns # an entire new one, rather than the normal function which is fed one # at a time (and can return any number of results) t_out_bs = step['translation']['multi_function'](t_in_bs) if t_out_bs == None : t_out_bs = t_in_bs self.t_out_b_valid(step, t_out_bs, t_to_q_out_b) # allow multi_function to return a single dict, if that is the # only binding in the result set if isinstance(t_out_bs, dict) : t_out_bs = [t_out_bs] q_out_bs = [self.map_t_to_q(t_out_b, t_to_q_out_b) for t_out_b in t_out_bs] else : raise Exception("translation doesn't have a function ...") # handle values which are lists, which were really short hand for many # possibilities (see glob.glob) q_out_bs = explode_bindings_set(q_out_bs) return q_out_bs