"""Return a composite column-based property for use with a Mapper.
This is very much like a column-based property except the given class
- is used to construct values composed of one or more columns. The class must
- implement a constructor with positional arguments matching the order of
- columns given, as well as a __colset__() method which returns its attributes
- in column order.
+ is used to represent "composite" values composed of one or more columns.
+
+ The class must implement a constructor with positional arguments matching
+ the order of columns supplied here, as well as a __composite_values__()
+ method which returns values in the same order.
+
+ A simple example is representing separate two columns in a table as a
+ single, first-class "Point" object::
+
+ class Point(object):
+ def __init__(self, x, y):
+ self.x = x
+ self.y = y
+ def __composite_values__(self):
+ return (self.x, self.y)
+
+ # and then in the mapping:
+ ... composite(Point, mytable.c.x, mytable.c.y) ...
+
+ Arguments are:
- class\_
- the "composite type" class.
+ class\_
+ The "composite type" class.
- \*cols
- list of Column objects to be mapped.
+ \*cols
+ List of Column objects to be mapped.
- group
- a group name for this property when marked as deferred.
+ group
+ A group name for this property when marked as deferred.
- deferred
- when True, the column property is "deferred", meaning that
- it does not load immediately, and is instead loaded when the
- attribute is first accessed on an instance. See also
- [sqlalchemy.orm#deferred()].
+ deferred
+ When True, the column property is "deferred", meaning that
+ it does not load immediately, and is instead loaded when the
+ attribute is first accessed on an instance. See also
+ [sqlalchemy.orm#deferred()].
- comparator
- an optional instance of [sqlalchemy.orm#PropComparator] which
- provides SQL expression generation functions for this composite
- type.
+ comparator
+ An optional instance of [sqlalchemy.orm#PropComparator] which
+ provides SQL expression generation functions for this composite
+ type.
"""
return CompositeProperty(class_, *cols, **kwargs)
return ExtensionOption(ext)
def eagerload(name):
- """Return a ``MapperOption`` that will convert the property of the
- given name into an eager load.
+ """Return a ``MapperOption`` that will convert the property of the given name into an eager load.
Used with ``query.options()``.
"""
return strategies.EagerLazyOption(name, lazy=False)
def eagerload_all(name):
- """Return a ``MapperOption`` that will convert all
- properties along the given dot-separated path into an
- eager load.
+ """Return a ``MapperOption`` that will convert all properties along the given dot-separated path into an eager load.
- e.g::
+ For example, this::
+
query.options(eagerload_all('orders.items.keywords'))...
will set all of 'orders', 'orders.items', and 'orders.items.keywords'
obj = getattr(object, self.key, None)
if obj is None:
obj = self.composite_class(*[None for c in self.columns])
- for a, b in zip(self.columns, value.__colset__()):
+ for a, b in zip(self.columns, value.__composite_values__()):
if a is column:
setattr(obj, b, value)
def get_col_value(self, column, value):
- for a, b in zip(self.columns, value.__colset__()):
+ for a, b in zip(self.columns, value.__composite_values__()):
if a is column:
return b
if other is None:
return sql.and_(*[a==None for a in self.prop.columns])
else:
- return sql.and_(*[a==b for a, b in zip(self.prop.columns, other.__colset__())])
+ return sql.and_(*[a==b for a, b in
+ zip(self.prop.columns,
+ other.__composite_values__())])
def __ne__(self, other):
- return sql.or_(*[a!=b for a, b in zip(self.prop.columns, other.__colset__())])
+ return sql.or_(*[a!=b for a, b in
+ zip(self.prop.columns,
+ other.__composite_values__())])
class PropertyLoader(StrategizedProperty):
"""Describes an object property that holds a single item or list
def _init_composite_attribute(self):
self.logger.info("register managed composite attribute %s on class %s" % (self.key, self.parent.class_.__name__))
def copy(obj):
- return self.parent_property.composite_class(*obj.__colset__())
+ return self.parent_property.composite_class(
+ *obj.__composite_values__())
def compare(a, b):
- for col, aprop, bprop in zip(self.columns, a.__colset__(), b.__colset__()):
+ for col, aprop, bprop in zip(self.columns,
+ a.__composite_values__(),
+ b.__composite_values__()):
if not col.type.compare_values(aprop, bprop):
return False
else:
def __init__(self, x, y):
self.x = x
self.y = y
- def __colset__(self):
+ def __composite_values__(self):
return [self.x, self.y]
def __eq__(self, other):
return other.x == self.x and other.y == self.y
def __init__(self, id, version):
self.id = id
self.version = version
- def __colset__(self):
- return [self.id, self.version]
+ def __composite_values__(self):
+ # a tuple this time
+ return (self.id, self.version)
def __eq__(self, other):
return other.id == self.id and other.version == self.version
def __ne__(self, other):
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
