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 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)
def get_where_for_join(self):
return compare_columns(self.local_key, self.remote_key)