Python sqlalchemy.orm.relationship() Examples

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 {} 

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 {} 

def annotation_association(cls):
        name = cls.__name__
        discriminator = name.lower()

        assoc_cls = type(
            "%sAnnotationAssociation" % name, (AnnotationAssociation,),
            dict(
                __tablename__ = None,
                __mapper_args__ = {"polymorphic_identity": discriminator},
            ),
        )

        cls.annotation = association_proxy(
            "annotation_association",
            "annotation",
            creator = lambda annotation: assoc_cls(annotation = annotation),
        )
        return relationship(
            assoc_cls, backref = backref("parent", uselist = False, collection_class = ordering_list('position'))
        ) 

def phys_unit(cls):
        return relationship("PhysUnit") 

def candidate(cls) -> relationship:
        """``Candidate``."""
        return relationship(
            "Candidate",
            backref=backref(
                camel_to_under(cls.__name__) + "s",
                cascade="all, delete-orphan",
                cascade_backrefs=False,
            ),
            cascade_backrefs=False,
        ) 

def test_serialize_resource_with_to_many_relationship_success(self):
        """Serailize a resource with a to-many relationship."""

        class UserSerializer(serializer.JSONAPISerializer):
            """Declarative serializer for User."""
            fields = ['id', 'first_name']
            model = self.User

        user = self.User(first_name='Sally')
        self.session.add(user)
        self.session.commit()
        user = self.session.query(self.User).get(user.id)

        user_serializer = UserSerializer()
        serialized_data = user_serializer.serialize(user)

        expected_data = {
            'data': {
                'id': str(user.id),
                'type': user.__tablename__,
                'attributes': {
                    'first-name': u'{}'.format(user.first_name)
                },
                'relationships': {
                    'posts': {
                        'links': {
                            'self': '/users/1/relationships/posts',
                            'related': '/users/1/posts'
                        }
                    }
                }
            },
            'meta': {
                'sqlalchemy_jsonapi_version': '4.0.9'
            },
            'jsonapi': {
                'version': '1.0'
            }
        }
        self.assertEqual(expected_data, serialized_data) 

def test_serialize_resource_with_to_one_relationship_success(self):
        """Serialize a resource with a to-one relationship."""

        class PostSerializer(serializer.JSONAPISerializer):
            """Declarative serializer for Post."""
            fields = ['id', 'title']
            model = self.Post

        blog_post = self.Post(title='Foo')
        self.session.add(blog_post)
        self.session.commit()
        post = self.session.query(self.Post).get(blog_post.id)

        blog_post_serializer = PostSerializer()
        serialized_data = blog_post_serializer.serialize(post)

        expected_data = {
            'data': {
                'id': str(blog_post.id),
                'type': blog_post.__tablename__,
                'attributes': {
                    'title': u'{}'.format(blog_post.title)
                },
                'relationships': {
                    'blog-author': {
                        'links': {
                            'self': '/posts/1/relationships/blog-author',
                            'related': '/posts/1/blog-author'
                        }
                    }
                }
            },
            'meta': {
                'sqlalchemy_jsonapi_version': '4.0.9'
            },
            'jsonapi': {
                'version': '1.0'
            }
        }
        self.assertEqual(expected_data, serialized_data) 

def setUp(self):
        """Configure sqlalchemy and session."""
        self.engine = create_engine('sqlite://')
        Session = sessionmaker(bind=self.engine)
        self.session = Session()
        self.Base = declarative_base()

        class User(self.Base):
            __tablename__ = 'users'
            id = Column(Integer, primary_key=True)
            first_name = Column(String(50), nullable=False)

        class Post(self.Base):
            __tablename__ = 'posts'
            id = Column(Integer, primary_key=True)
            title = Column(String(100), nullable=False)
            author_id = Column(Integer, ForeignKey('users.id',
                                                   ondelete='CASCADE'))

            blog_author = relationship('User',
                                       lazy='joined',
                                       backref=backref('posts',
                                                       lazy='dynamic',
                                                       cascade='all,delete'))

        self.User = User
        self.Post = Post
        self.Base.metadata.create_all(self.engine) 

def symbol_link(cls):
        return relationship("SymbolLink") 

def step_size(cls):
        return relationship("StepSize") 

def ref_unit(cls):
        return relationship("RefUnit") 

def ref_characteristic(cls):
        return relationship("RefCharacteristic") 

def version(cls):
        return relationship("Version") 

def calibration_access(cls):
        return relationship("CalibrationAccess") 

def byte_order(cls):
        return relationship("ByteOrder") 

def bit_mask(cls):
        return relationship("BitMask") 

def alignment_long(cls):
        return relationship("AlignmentLong") 

def alignment_int64(cls):
        return relationship("AlignmentInt64") 

def alignment_float64_ieee(cls):
        return relationship("AlignmentFloat64Ieee") 

def alignment_float32_ieee(cls):
        return relationship("AlignmentFloat32Ieee") 

def alignment_byte(cls):
        return relationship("AlignmentByte") 

def assigned(cls):
        return relationship('Person', backref='tasks') 

def user(cls):
        return relationship(
            'User',
            backref=backref("mailinglists", cascade="all, delete-orphan")
        ) 

def user(cls):
        return relationship(
            'User',
            backref=backref("registrations", cascade="all, delete-orphan")
        ) 

def user(cls):
        return relationship(
            'User',
            backref=backref("tokens", cascade="all,delete")) 

def permissions(cls):
        return relationship("Permission",
                            secondary='groups_permissions',
                            backref="groups") 

def users(cls):
        return relationship("User",
                            secondary='users_groups',
                            backref='groups') 

def reference_col(tablename, nullable=False, pk_name='id', **kwargs):
    """Column that adds primary key foreign key reference.

    Usage: ::

        category_id = reference_col('category')
        category = relationship('Category', backref='categories')
    """
    return db.Column(
        db.ForeignKey('{0}.{1}'.format(tablename, pk_name)),
        nullable=nullable, **kwargs) 

def _gateway_device_relation(class_name, ref_key):
    relation = "GatewayDevice.id==" + class_name + ".device_id"
    return orm.relationship(
        GatewayDevice,
        backref=orm.backref(ref_key, cascade='delete', lazy='joined'),
        primaryjoin=relation) 

def cell(cls) -> relationship:
        """Parent ``Cell``, if any."""
        return relationship(
            "Cell",
            backref=backref("sentences", cascade="all, delete-orphan"),
            foreign_keys=lambda: cls.cell_id,
        )