def get_where_for_local(self, other): """Generate a column comparison expression for reference properties. The returned expression may be used to find objects of the I{local} type referring to C{other}. It handles the following cases:: Class.reference == obj Class.reference == obj.id Class.reference == (obj.id1, obj.id2) Where the right-hand side is the C{other} object given. """ try: obj_info = get_obj_info(other) except ClassInfoError: if type(other) is not tuple: remote_variables = (other, ) else: remote_variables = other else: # Don't use other here, as it might be # security proxied or something. other = get_obj_info(other).get_obj() remote_variables = self.get_remote_variables(other) return compare_columns(self.local_key, remote_variables)
def get_where_for_local(self, other): """Generate a column comparison expression for reference properties. The returned expression may be used to find objects of the I{local} type referring to C{other}. It handles the following cases:: Class.reference == obj Class.reference == obj.id Class.reference == (obj.id1, obj.id2) Where the right-hand side is the C{other} object given. """ try: obj_info = get_obj_info(other) except ClassInfoError: if type(other) is not tuple: remote_variables = (other,) else: remote_variables = other else: # Object may be security proxied or something, so # we get the real object here. # XXX UNTESTED! other = obj_info.get_obj() remote_variables = self.get_remote_variables(other) return compare_columns(self.local_key, remote_variables)
def get(self, cls, key, **options): """Get object of type cls with the given primary key from the database. If the object is alive the database won't be touched. @param cls: Class of the object to be retrieved. @param key: Primary key of object. May be a tuple for composed keys. @return: The object found with the given primary key, or None if no object is found. """ for_update_nowait = options.get("for_update_nowait") if for_update_nowait is not True: for_update_nowait = False if self._implicit_flush_block_count == 0: self.flush() if type(key) != tuple: key = (key, ) cls_info = get_cls_info(cls) assert len(key) == len(cls_info.primary_key) primary_vars = [] for column, variable in zip(cls_info.primary_key, key): if not isinstance(variable, Variable): variable = column.variable_factory(value=variable) primary_vars.append(variable) primary_values = tuple(var.get(to_db=True) for var in primary_vars) obj_info = self._alive.get((cls_info.cls, primary_values)) if obj_info is not None and not obj_info.get("invalidated"): return self._get_object(obj_info) where = compare_columns(cls_info.primary_key, primary_vars) select = Select(cls_info.columns, where, default_tables=cls_info.table, limit=1, for_update_nowait=for_update_nowait) try: result = self._connection.execute(select) except Exception as db_error: if db_error[0].code == RESOURCE_BUSY_ERROR_CODE: # Resource busy raise DatabaseResourceBusyException( _(RESOURCE_BUSY_ERROR_MESSAGE)) raise db_error values = result.get_one() if values is None: return None return self._load_object(cls_info, result, values)
def get_where_for_remote(self, local): """Generate a column comparison expression for reference properties. The returned expression may be used to find objects of the I{remote} type referring to C{local}. """ local_variables = self.get_local_variables(local) for variable in local_variables: if not variable.is_defined(): Store.of(local).flush() break return compare_columns(self.remote_key, local_variables)
def join_aliased_relation(local_cls, remote_cls, relation): """Build a join expression between local_cls and remote_cls. This is equivalent to relation.get_where_for_join(), except that the join expression is changed to be relative to the given local_cls and remote_cls (which may be aliases). The result is the join expression. """ remote_key = tuple( Column(column.name, remote_cls) for column in relation.remote_key) local_key = tuple( Column(column.name, local_cls) for column in relation.local_key) return compare_columns(local_key, remote_key)
def join_aliased_relation(local_cls, remote_cls, relation): """Build a join expression between local_cls and remote_cls. This is equivalent to relation.get_where_for_join(), except that the join expression is changed to be relative to the given local_cls and remote_cls (which may be aliases). The result is the join expression. """ remote_key = tuple(Column(column.name, remote_cls) for column in relation.remote_key) local_key = tuple(Column(column.name, local_cls) for column in relation.local_key) return compare_columns(local_key, remote_key)
def get_where_for_join(self): return compare_columns(self.local_key, self.remote_key)