def composite(class_, *cols, **kwargs):
"""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 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.
\*cols
List of Column objects to be mapped.
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()].
comparator
An optional instance of [sqlalchemy.orm#PropComparator] which
provides SQL expression generation functions for this composite
type.
"""
return CompositeProperty(class_, *cols, **kwargs)
def composite(class_, *cols, **kwargs):
"""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 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
def __eq__(self, other):
return other is not None and self.x == other.x and self.y == other.y
# and then in the mapping:
... composite(Point, mytable.c.x, mytable.c.y) ...
The composite object may have its attributes populated based on the names
of the mapped columns. To override the way internal state is set,
additionally implement ``__set_composite_values__``::
class Point(object):
def __init__(self, x, y):
self.some_x = x
self.some_y = y
def __composite_values__(self):
return self.some_x, self.some_y
def __set_composite_values__(self, x, y):
self.some_x = x
self.some_y = y
def __eq__(self, other):
return other is not None and self.some_x == other.x and self.some_y == other.y
Arguments are:
class\_
The "composite type" class.
\*cols
List of Column objects to be mapped.
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 :func:`~sqlalchemy.orm.deferred`.
comparator_factory
a class which extends ``sqlalchemy.orm.properties.CompositeProperty.Comparator``
which provides custom SQL clause generation for comparison operations.
extension
an :class:`~sqlalchemy.orm.interfaces.AttributeExtension` instance,
or list of extensions, which will be prepended to the list of
attribute listeners for the resulting descriptor placed on the class.
These listeners will receive append and set events before the
operation proceeds, and may be used to halt (via exception throw)
or change the value used in the operation.
"""
return CompositeProperty(class_, *cols, **kwargs)