Skip to content

Model#

Bases: SsasModelRecord

tbd.

SSAS spec: Microsoft

Source code in pbi_core/ssas/model_tables/model/model.py 
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@define()
class Model(SsasModelRecord):
    """tbd.

    SSAS spec: [Microsoft](https://learn.microsoft.com/en-us/openspecs/sql_server_protocols/ms-ssas-t/60094cd5-1c7e-4353-9299-251bfa838cc6)
    """

    _default_refresh_type: RefreshType = field(default=RefreshType.CALCULATE, init=False, repr=False, eq=False)

    automatic_aggregation_options: str | None = field(default=None, eq=True)
    collation: str | None = field(default=None, eq=True)
    culture: str = field(eq=True)
    data_access_options: Json[DataAccessOptions] = field(factory=DataAccessOptions, eq=True)
    data_source_default_max_connections: int = field(eq=True)
    data_source_variables_override_behavior: int = field(eq=True)
    default_data_view: DefaultDataView = field(eq=True)
    default_measure_id: int | None = field(default=None, eq=True)
    default_mode: int = field(eq=True)
    default_powerbi_data_source_version: int = field(eq=True)
    description: str | None = field(default=None, eq=True)
    discourage_composite_models: bool = field(default=True, eq=True)
    discourage_implicit_measures: bool = field(default=False, eq=True)
    disable_auto_exists: int | None = field(default=None, eq=True)
    force_unique_names: bool = field(default=False, eq=True)
    m_attributes: str | None = field(default=None, eq=True)
    max_parallelism_per_refresh: int | None = field(default=None, eq=True)
    max_parallelism_per_query: int | None = field(default=None, eq=True)
    name: str = field(eq=True)
    source_query_culture: str = field(default="en-US", eq=True)
    storage_location: str | None = field(default=None, eq=True)
    version: int = field(eq=True)

    modified_time: Final[datetime.datetime] = field(
        eq=False,
        on_setattr=setters.frozen,
        repr=False,
    )
    structure_modified_time: Final[datetime.datetime] = field(
        eq=False,
        on_setattr=setters.frozen,
        repr=False,
    )

    _commands: ModelCommands = field(default=SsasCommands.model, init=False, repr=False, eq=False)

    def default_measure(self) -> "Measure | None":
        if self.default_measure_id is None:
            return None
        return self._tabular_model.measures.find(self.default_measure_id)

    def cultures(self) -> set["Culture"]:
        return self._tabular_model.cultures.find_all({"model_id": self.id})

    def data_sources(self) -> set["DataSource"]:
        return self._tabular_model.data_sources.find_all({"model_id": self.id})

    def expressions(self) -> set["Expression"]:
        return self._tabular_model.expressions.find_all({"model_id": self.id})

    def perspectives(self) -> set["Perspective"]:
        return self._tabular_model.perspectives.find_all({"model_id": self.id})

    def query_groups(self) -> set["QueryGroup"]:
        return self._tabular_model.query_groups.find_all({"model_id": self.id})

    def relationships(self) -> set["Relationship"]:
        return self._tabular_model.relationships.find_all({"model_id": self.id})

    def roles(self) -> set["Role"]:
        return self._tabular_model.roles.find_all({"model_id": self.id})

    def tables(self) -> set["Table"]:
        return self._tabular_model.tables.find_all({"model_id": self.id})

    def children_base(self) -> frozenset["LinkedEntity"]:
        return (
            LinkedEntity.from_iter(self.annotations(), by="annotation")
            | LinkedEntity.from_iter(self.cultures(), by="culture")
            | LinkedEntity.from_iter(
                self.data_sources(),
                by="data_source",
            )
            | LinkedEntity.from_iter(self.expressions(), by="expression")
            | LinkedEntity.from_iter(
                self.perspectives(),
                by="perspective",
            )
            | LinkedEntity.from_iter(self.query_groups(), by="query_group")
            | LinkedEntity.from_iter(
                self.relationships(),
                by="relationship",
            )
            | LinkedEntity.from_iter(self.roles(), by="role")
            | LinkedEntity.from_iter(self.tables(), by="table")
        )