cubicweb: comparison cubicweb/server/ssplanner.py

equal deleted inserted replaced

-:2e2425d2d54d
+:dc333e9104c9
-# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of CubicWeb.
 #
 # CubicWeb is free software: you can redistribute it and/or modify it under the
 READ_ONLY_RTYPES = set(('eid', 'has_text', 'is', 'is_instance_of', 'identity'))
 _CONSTANT = object()
 _FROM_SUBSTEP = object()
 def _extract_const_attributes(plan, rqlst, to_build):
 """add constant values to entity def, mark variables to be selected
 """
 to_select = {}
 edef.edited_attribute(rtype, value)
 elif str(rhs) in to_build:
 # create a relation between two newly created variables
 plan.add_relation_def((edef, rtype, to_build[rhs.name]))
 else:
-to_select.setdefault(edef, []).append( (rtype, rhs, 0) )
+to_select.setdefault(edef, []).append((rtype, rhs, 0))
 return to_select
 def _extract_eid_consts(plan, rqlst):
 """return a dict mapping rqlst variable object to their eid if specified in
 the syntax tree
 """
 checkread = cnx.read_security
 eschema = cnx.vreg.schema.eschema
 for rel in rqlst.where.get_nodes(Relation):
 # only care for 'eid' relations ...
 if (rel.r_type == 'eid'
 # ... that are not part of a NOT clause ...
 and not rel.neged(strict=True)
 # ... and where eid is specified by '=' operator.
 and rel.children[1].operator == '='):
 lhs, rhs = rel.get_variable_parts()
 if isinstance(rhs, Constant):
 eid = int(rhs.eval(plan.args))
 # check read permission here since it may not be done by
 # the generated select substep if not emited (eg nothing
 with cnx.security_enabled(read=False):
 eschema(cnx.entity_type(eid)).check_perm(
 cnx, 'read', eid=eid)
 eidconsts[lhs.variable] = eid
 return eidconsts
 def _build_substep_query(select, origrqlst):
 """Finalize substep select query that should be executed to get proper
 selection of stuff to insert/update.
 if getattr(origrqlst, 'having', None):
 select.set_having([sq.copy(select) for sq in origrqlst.having])
 return select
 return None
 class SSPlanner(object):
 """SingleSourcePlanner: build execution plan for rql queries
 optimized for single source repositories
 """
 to_build[var.name] = EditedEntity(etype_class(etype)(cnx))
 plan.add_entity_def(to_build[var.name])
 # add constant values to entity def, mark variables to be selected
 to_select = _extract_const_attributes(plan, rqlst, to_build)
 # add necessary steps to add relations and update attributes
-step = InsertStep(plan) # insert each entity and its relations
+step = InsertStep(plan)  # insert each entity and its relations
 step.children += self._compute_relation_steps(plan, rqlst, to_select)
 return (step,)
 def _compute_relation_steps(self, plan, rqlst, to_select):
 """handle the selection of relations for an insert query"""
 def build_set_plan(self, plan, rqlst):
 """get an execution plan from an SET RQL query"""
 getrschema = self.schema.rschema
 select = Select()   # potential substep query
 selectedidx = {}    # local state
-attributes = set()  # edited attributes
 updatedefs = []     # definition of update attributes/relations
-selidx = residx = 0 # substep selection / resulting rset indexes
+selidx = residx = 0  # substep selection / resulting rset indexes
 # search for eid const in the WHERE clause
 eidconsts = _extract_eid_consts(plan, rqlst)
 # build `updatedefs` describing things to update and add necessary
 # variables to the substep selection
 for i, relation in enumerate(rqlst.main_relations):
 if relation.r_type in VIRTUAL_RTYPES:
 raise QueryError('can not assign to %r relation'
 % relation.r_type)
 lhs, rhs = relation.get_variable_parts()
 lhskey = lhs.as_string()
-if not lhskey in selectedidx:
+if lhskey not in selectedidx:
 if lhs.variable in eidconsts:
 eid = eidconsts[lhs.variable]
 lhsinfo = (_CONSTANT, eid, residx)
 else:
 select.append_selected(lhs.copy(select))
 residx += 1
 selectedidx[lhskey] = lhsinfo
 else:
 lhsinfo = selectedidx[lhskey][:-1] + (None,)
 rhskey = rhs.as_string()
-if not rhskey in selectedidx:
+if rhskey not in selectedidx:
 if isinstance(rhs, Constant):
 rhsinfo = (_CONSTANT, rhs.eval(plan.args), residx)
 elif getattr(rhs, 'variable', None) in eidconsts:
 eid = eidconsts[rhs.variable]
 rhsinfo = (_CONSTANT, eid, residx)
 residx += 1
 selectedidx[rhskey] = rhsinfo
 else:
 rhsinfo = selectedidx[rhskey][:-1] + (None,)
 rschema = getrschema(relation.r_type)
-updatedefs.append( (lhsinfo, rhsinfo, rschema) )
+updatedefs.append((lhsinfo, rhsinfo, rschema))
 # the update step
 step = UpdateStep(plan, updatedefs)
 # when necessary add substep to fetch yet unknown values
 select = _build_substep_query(select, rqlst)
 if select is not None:
 else:
 cachekey = union.as_string()
 # get results for query
 source = cnx.repo.system_source
 result = source.syntax_tree_search(cnx, union, args, cachekey)
-#print 'ONEFETCH RESULT %s' % (result)
 return result
 def mytest_repr(self):
 """return a representation of this step suitable for test"""
 return (self.__class__.__name__,
 value = row[index]
 index += 1
 if rorder == InsertRelationsStep.FINAL:
 edef.edited_attribute(rtype, value)
 elif rorder == InsertRelationsStep.RELATION:
-self.plan.add_relation_def( (edef, rtype, value) )
+self.plan.add_relation_def((edef, rtype, value))
 edef.querier_pending_relations[(rtype, 'subject')] = value
 else:
-self.plan.add_relation_def( (value, rtype, edef) )
+self.plan.add_relation_def((value, rtype, edef))
 edef.querier_pending_relations[(rtype, 'object')] = value
 edefs.append(edef)
 self.plan.substitute_entity_def(base_edef, edefs)
 return result
 if results:
 todelete = frozenset(int(eid) for eid, in results)
 cnx = self.plan.cnx
 cnx.repo.glob_delete_entities(cnx, todelete)
 return results
 class DeleteRelationsStep(Step):
 """step consisting in deleting relations"""
 def __init__(self, plan, rtype):
 repo.glob_add_relations(cnx, relations)
 for eid, edited in edefs.items():
 repo.glob_update_entity(cnx, edited)
 return result
 def _handle_relterm(info, row, newrow):
 if info[0] is _CONSTANT:
 val = info[1]
-else: # _FROM_SUBSTEP
+else:  # _FROM_SUBSTEP
 val = row[info[1]]
 if info[-1] is not None:
 newrow.append(val)
 return val

changeset 12227	dc333e9104c9
parent 11767	432f87a63057
child 12242	68ca7fe0ca29