Python sqlalchemy.orm.RelationshipProperty() Examples

def is_like_list(instance, relation):
    """Returns ``True`` if and only if the relation of `instance` whose name is
    `relation` is list-like.

    A relation may be like a list if, for example, it is a non-lazy one-to-many
    relation, or it is a dynamically loaded one-to-many.

    """
    if relation in instance._sa_class_manager:
        return instance._sa_class_manager[relation].property.uselist
    elif hasattr(instance, relation):
        attr = getattr(instance._sa_instance_state.class_, relation)
        if hasattr(attr, 'property'):
            return attr.property.uselist
    related_value = getattr(type(instance), relation, None)
    if isinstance(related_value, AssociationProxy):
        local_prop = related_value.local_attr.prop
        if isinstance(local_prop, RelProperty):
            return local_prop.uselist
    return False 

def get_field_type(model, fieldname):
    """Helper which returns the SQLAlchemy type of the field.

    """
    field = getattr(model, fieldname)
    if isinstance(field, ColumnElement):
        fieldtype = field.type
    else:
        if isinstance(field, AssociationProxy):
            field = field.remote_attr
        if hasattr(field, 'property'):
            prop = field.property
            if isinstance(prop, RelProperty):
                return None
            fieldtype = prop.columns[0].type
        else:
            return None
    return fieldtype 

def contribute_to_class(self, mcs_args: McsArgs, relationships):
        if mcs_args.Meta.abstract:
            return

        discovered_relationships = {}

        def discover_relationships(d):
            for k, v in d.items():
                if isinstance(v, RelationshipProperty):
                    discovered_relationships[v.argument] = k
                    if v.backref and mcs_args.Meta.lazy_mapped:
                        raise NotImplementedError(
                            f'Discovered a lazy-mapped backref `{k}` on '
                            f'`{mcs_args.qualname}`. Currently this '
                            'is unsupported; please use `db.relationship` with '
                            'the `back_populates` kwarg on both sides instead.')

        for base in mcs_args.bases:
            discover_relationships(vars(base))
        discover_relationships(mcs_args.clsdict)

        relationships.update(discovered_relationships) 

def object_as_dict(obj, relationships=False):
    """
    Converts an SQLAlchemy instance to a dictionary.

    :param relationships: If true, also include relationships in the output dict
    """
    properties = inspect(obj).mapper.all_orm_descriptors

    if not relationships:
        properties = {
            key: value
            for key, value in properties.items()
            if not hasattr(value, "prop")
            or not isinstance(value.prop, RelationshipProperty)
        }

    return {key: getattr(obj, key) for key, value in properties.items()} 

def _should_exclude_field(column, fields=None, exclude=None,
                          include_related=None):
    if fields and column.key not in fields:
        return True
    if exclude and column.key in exclude:
        return True
    if isinstance(column, RelationshipProperty) and not include_related:
        return True
    return False 

def datasource(self) -> RelationshipProperty:
        return self.table 

def slices(self) -> RelationshipProperty:
        return relationship(
            "Slice",
            primaryjoin=lambda: and_(
                foreign(Slice.datasource_id) == self.id,
                foreign(Slice.datasource_type) == self.type,
            ),
        )

    # placeholder for a relationship to a derivative of BaseColumn 

def user(self) -> RelationshipProperty:
        return relationship(
            security_manager.user_model,
            backref=self.__tablename__,
            foreign_keys=[self.user_id],
        ) 

def apply_nested_fields(self, data, obj):
        nested_fields_to_apply = []
        nested_fields = get_nested_fields(self.resource.schema, model_field=True)
        for key, value in data.items():
            if key in nested_fields:
                nested_field_inspection = inspect(getattr(obj.__class__, key))

                if not isinstance(nested_field_inspection, QueryableAttribute):
                    raise InvalidType("Unrecognized nested field type: not a queryable attribute.")

                if isinstance(nested_field_inspection.property, RelationshipProperty):
                    nested_model = getattr(obj.__class__, key).property.mapper.class_

                    if isinstance(value, list):
                        nested_objects = []

                        for identifier in value:
                            nested_object = nested_model(**identifier)
                            nested_objects.append(nested_object)

                        nested_fields_to_apply.append({'field': key, 'value': nested_objects})
                    else:
                        nested_fields_to_apply.append({'field': key, 'value': nested_model(**value)})
                elif isinstance(nested_field_inspection.property, ColumnProperty):
                    nested_fields_to_apply.append({'field': key, 'value': value})
                else:
                    raise InvalidType("Unrecognized nested field type: not a RelationshipProperty or ColumnProperty.")

        for nested_field in nested_fields_to_apply:
            setattr(obj, nested_field['field'], nested_field['value']) 

def get_related_model(model, relationname):
    """Gets the class of the model to which `model` is related by the attribute
    whose name is `relationname`.

    """
    if hasattr(model, relationname):
        attr = getattr(model, relationname)
        if hasattr(attr, 'property') \
                and isinstance(attr.property, RelProperty):
            return attr.property.mapper.class_
        if isinstance(attr, AssociationProxy):
            return get_related_association_proxy_model(attr)
    return None 

def test_columns(self, table):
        """Tests the columns in database table. If a column exists in the
        table, check that the column has correct datatype. If the column
        doesn't exist, add a MissingColumn object to the error list.
        """
        columns = self.inspection_engine.get_columns(table)
        column_names = [c["name"] for c in columns]

        # Search for correct class from models for the mapper.
        mapper = None
        for name, class_ in self.model_tables:
            if class_.__tablename__ == table:
                mapper = inspect(class_)
                break
        if not mapper:
            return

        for column_property in mapper.attrs:
            if isinstance(column_property, RelationshipProperty):
                # TODO: Add RelationshipProperty sanity checking.
                pass
            else:
                for column in column_property.columns:
                    if column.key in column_names:
                        self.test_datatype(table, column)
                        self.test_nullable(table, column)
                    else:
                        self.errors.append(MissingColumn(table, column.key,
                                                         parent=self)) 

def relations(cls):
        """Return a `list` of relationship names or the given model
        """
        return [c.key for c in cls.__mapper__.iterate_properties
                if isinstance(c, RelationshipProperty)] 

def as_relation_of(self, mongoquery: 'MongoQuery', relationship: RelationshipProperty) -> 'MongoQuery':
        """ Handle the query as a sub-query handling a relationship

        This is used by the MongoJoin handler to build queries to related models.

        :param mongoquery: The parent query
        :param relationship: The relationship
        """
        return self.as_relation(mongoquery._join_path + (relationship,)) 

def _is_relationship_array(rel: RelationshipProperty) -> bool:
    """ Is the relationship an array relationship? """
    return rel.property.uselist 

def get_relationship(self, col_name: str) -> RelationshipProperty:
        return self._rel_bag[self.get_relationship_name(col_name)] 

def __getitem__(self, name: str) -> RelationshipProperty:
        return self._relations[name] 

def __iter__(self) -> Iterable[Tuple[str, RelationshipProperty]]:
        """ Get relationships """
        return iter(self._relations.items()) 

def __init__(self, relationships: Mapping[str, RelationshipProperty]):
        """ Init relationships
        :param relationships: Model relationships
        """
        super(RelationshipsBag, self).__init__()
        self._relations = relationships
        self._rel_names = frozenset(self._relations.keys())
        self._array_rel_names = frozenset(name
                                          for name, rel in self._relations.items()
                                          if _is_relationship_array(rel)) 

def is_sane_database(Base, session):  # pragma: no cover
    """
    from: http://stackoverflow.com/questions/30428639/check-database-schema-matches-sqlalchemy-models-on-application-startup
    Check whether the current database matches the models declared in model base.

    Currently we check that all tables exist with all columns. What is not checked

    * Column types are not verified

    * Relationships are not verified at all (TODO)

    :param Base: Declarative Base for SQLAlchemy models to check

    :param session: SQLAlchemy session bound to an engine

    :return: True if all declared models have corresponding tables and columns.
    """
    engine = session.get_bind()
    iengine = inspect(engine)
    errors = False
    tables = iengine.get_table_names()

    # Go through all SQLAlchemy models
    for name, klass in Base._decl_class_registry.items():
        if isinstance(klass, _ModuleMarker):
            # Not a model
            continue
        table = klass.__tablename__
        if table in tables:
            # Check all columns are found
            # Looks like [{'default': "nextval('sanity_check_test_id_seq'::regclass)", 'autoincrement': True, 'nullable': False, 'type': INTEGER(), 'name': 'id'}]
            columns = [c["name"] for c in iengine.get_columns(table)]
            mapper = inspect(klass)
            for column_prop in mapper.attrs:
                if isinstance(column_prop, RelationshipProperty):
                    # TODO: Add sanity checks for relations
                    pass
                else:
                    for column in column_prop.columns:
                        # Assume normal flat column
                        if column.key not in columns:
                            logger.error(
                                "Model %s declares column %s which does not exist in database %s",
                                klass, column.key, engine
                            )
                            errors = True
        else:
            logger.error(
                "Model %s declares table %s which does not exist in database %s", klass, table,
                engine
            )
            errors = True
    return not errors