Python sqlalchemy.orm.composite() Examples
The following are 30
code examples of sqlalchemy.orm.composite().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
sqlalchemy.orm
, or try the search function
.
Example #1
Source File: interfaces.py From moviegrabber with GNU General Public License v3.0 | 6 votes |
def info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.MapperProperty`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #2
Source File: interfaces.py From jbox with MIT License | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #3
Source File: test_composites.py From sqlalchemy with MIT License | 6 votes |
def test_columns(self): edge, Edge, Point = ( self.tables.edge, self.classes.Edge, self.classes.Point, ) mapper( Edge, edge, properties={ "start": sa.orm.composite(Point, edge.c.x1, edge.c.y1), "end": sa.orm.composite(Point, edge.c.x2, edge.c.y2), }, ) self._test_roundtrip()
Example #4
Source File: test_composites.py From sqlalchemy with MIT License | 6 votes |
def test_deferred(self): edge, Edge, Point = ( self.tables.edge, self.classes.Edge, self.classes.Point, ) mapper( Edge, edge, properties={ "start": sa.orm.composite( Point, edge.c.x1, edge.c.y1, deferred=True, group="s" ), "end": sa.orm.composite( Point, edge.c.x2, edge.c.y2, deferred=True ), }, ) self._test_roundtrip()
Example #5
Source File: test_composites.py From sqlalchemy with MIT License | 6 votes |
def test_save_null(self): """test saving a null composite value See google groups thread for more context: http://groups.google.com/group/sqlalchemy/browse_thread/thread/0c6580a1761b2c29 """ Graph, Edge = self.classes.Graph, self.classes.Edge sess = Session() g = Graph(id=1) e = Edge(None, None) g.edges.append(e) sess.add(g) sess.commit() g2 = sess.query(Graph).get(1) assert g2.edges[-1].start.x is None assert g2.edges[-1].start.y is None
Example #6
Source File: test_composites.py From sqlalchemy with MIT License | 6 votes |
def test_not_none(self): Edge = self.classes.Edge # current contract. the composite is None # when hasn't been populated etc. on a # pending/transient object. e1 = Edge() assert e1.end is None sess = Session() sess.add(e1) # however, once it's persistent, the code as of 0.7.3 # would unconditionally populate it, even though it's # all None. I think this usage contract is inconsistent, # and it would be better that the composite is just # created unconditionally in all cases. # but as we are just trying to fix [ticket:2308] and # [ticket:2309] without changing behavior we maintain # that only "persistent" gets the composite with the # Nones sess.flush() assert e1.end is not None
Example #7
Source File: test_composites.py From sqlalchemy with MIT License | 6 votes |
def test_check_prop_type(self): edge, Edge, Point = ( self.tables.edge, self.classes.Edge, self.classes.Point, ) mapper( Edge, edge, properties={ "start": sa.orm.composite(Point, (edge.c.x1,), edge.c.y1) }, ) assert_raises_message( sa.exc.ArgumentError, # note that we also are checking that the tuple # renders here, so the "%" operator in the string needs to # apply the tuple also r"Composite expects Column objects or mapped " r"attributes/attribute names as " r"arguments, got: \(Column", configure_mappers, )
Example #8
Source File: interfaces.py From jarvis with GNU General Public License v2.0 | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #9
Source File: mutable.py From sqlalchemy with MIT License | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return {attribute.key}
Example #10
Source File: mutable.py From jarvis with GNU General Public License v2.0 | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return {attribute.key}
Example #11
Source File: interfaces.py From sqlalchemy with MIT License | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`_orm.relationship`, or :func:`.composite` functions. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #12
Source File: interfaces.py From stdm with GNU General Public License v2.0 | 6 votes |
def info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.MapperProperty`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #13
Source File: mutable.py From pyRevit with GNU General Public License v3.0 | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return set([attribute.key])
Example #14
Source File: test_mapper.py From sqlalchemy with MIT License | 6 votes |
def test_info(self): users = self.tables.users Address = self.classes.Address class MyComposite(object): pass for constructor, args in [ (column_property, (users.c.name,)), (relationship, (Address,)), (composite, (MyComposite, "id", "name")), (synonym, "foo"), ]: obj = constructor(info={"x": "y"}, *args) eq_(obj.info, {"x": "y"}) obj.info["q"] = "p" eq_(obj.info, {"x": "y", "q": "p"}) obj = constructor(*args) eq_(obj.info, {}) obj.info["q"] = "p" eq_(obj.info, {"q": "p"})
Example #15
Source File: interfaces.py From pyRevit with GNU General Public License v3.0 | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #16
Source File: mutable.py From planespotter with MIT License | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return {attribute.key}
Example #17
Source File: interfaces.py From android_universal with MIT License | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #18
Source File: interfaces.py From planespotter with MIT License | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #19
Source File: mutable.py From Fluid-Designer with GNU General Public License v3.0 | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return set([attribute.key])
Example #20
Source File: interfaces.py From Fluid-Designer with GNU General Public License v3.0 | 6 votes |
def _memoized_attr_info(self): """Info dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`.relationship`, or :func:`.composite` functions. .. versionadded:: 0.8 Added support for .info to all :class:`.MapperProperty` subclasses. .. versionchanged:: 1.0.0 :attr:`.MapperProperty.info` is also available on extension types via the :attr:`.InspectionAttrInfo.info` attribute, so that it can apply to a wider variety of ORM and extension constructs. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` """ return {}
Example #21
Source File: mutable.py From jbox with MIT License | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return set([attribute.key])
Example #22
Source File: mutable.py From android_universal with MIT License | 6 votes |
def _get_listen_keys(cls, attribute): """Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. .. versionadded:: 1.0.5 """ return {attribute.key}
Example #23
Source File: test_mutable.py From sqlalchemy with MIT License | 5 votes |
def setup_mappers(cls): foo = cls.tables.foo cls.Point = cls._type_fixture() mapper( Foo, foo, properties={"data": composite(cls.Point, foo.c.x, foo.c.y)}, )
Example #24
Source File: test_mutable.py From sqlalchemy with MIT License | 5 votes |
def setup_mappers(cls): foo = cls.tables.foo cls.Point = cls._type_fixture() mapper( FooWithEq, foo, properties={"data": composite(cls.Point, foo.c.x, foo.c.y)}, )
Example #25
Source File: test_composites.py From sqlalchemy with MIT License | 5 votes |
def test_early_configure(self): # test [ticket:2935], that we can call a composite # expression before configure_mappers() A = self.classes.A A.c.__clause_element__()
Example #26
Source File: test_mutable.py From sqlalchemy with MIT License | 5 votes |
def setup_mappers(cls): foo = cls.tables.foo Point = cls._type_fixture() mapper( Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)} )
Example #27
Source File: test_mutable.py From sqlalchemy with MIT License | 5 votes |
def setup_mappers(cls): foo = cls.tables.foo Point = cls._type_fixture() # in this case, this is not actually a MutableComposite. # so we don't expect it to track changes mapper( Foo, foo, properties={ "data": composite(lambda x, y: Point(x, y), foo.c.x, foo.c.y) }, )
Example #28
Source File: test_mutable.py From sqlalchemy with MIT License | 5 votes |
def setup_mappers(cls): foo = cls.tables.foo subfoo = cls.tables.subfoo Point = cls._type_fixture() mapper( Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)} ) mapper(SubFoo, subfoo, inherits=Foo)
Example #29
Source File: test_basic.py From sqlalchemy with MIT License | 5 votes |
def test_composite_inline(self): class AddressComposite(fixtures.ComparableEntity): def __init__(self, street, state): self.street = street self.state = state def __composite_values__(self): return [self.street, self.state] class User(Base, fixtures.ComparableEntity): __tablename__ = "user" id = Column( Integer, primary_key=True, test_needs_autoincrement=True ) address = composite( AddressComposite, Column("street", String(50)), Column("state", String(2)), ) Base.metadata.create_all() sess = Session() sess.add(User(address=AddressComposite("123 anywhere street", "MD"))) sess.commit() eq_( sess.query(User).all(), [User(address=AddressComposite("123 anywhere street", "MD"))], )
Example #30
Source File: test_basic.py From sqlalchemy with MIT License | 5 votes |
def test_composite_separate(self): class AddressComposite(fixtures.ComparableEntity): def __init__(self, street, state): self.street = street self.state = state def __composite_values__(self): return [self.street, self.state] class User(Base, fixtures.ComparableEntity): __tablename__ = "user" id = Column( Integer, primary_key=True, test_needs_autoincrement=True ) street = Column(String(50)) state = Column(String(2)) address = composite(AddressComposite, street, state) Base.metadata.create_all() sess = Session() sess.add(User(address=AddressComposite("123 anywhere street", "MD"))) sess.commit() eq_( sess.query(User).all(), [User(address=AddressComposite("123 anywhere street", "MD"))], )