fabricks 3.0.5.2__py3-none-any.whl → 3.0.7__py3-none-any.whl

fabricks/metastore/table.py

@@ -1,5 +1,5 @@
 import re
-from typing import List, Optional, Sequence, Union, overload
+from typing import Any, List, Optional, Sequence, Union, overload
 
 from delta import DeltaTable
 from pyspark.errors.exceptions.base import AnalysisException
@@ -38,25 +38,25 @@ class Table(DbObject):
 
     @property
     def dataframe(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"select * from {self}")
 
     @property
     def columns(self) -> List[str]:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.dataframe.columns
 
     @property
     def rows(self) -> int:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"select count(*) from {self}").collect()[0][0]
 
     @property
     def last_version(self) -> int:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         df = self.describe_history()
         version = df.select(max("version")).collect()[0][0]
@@ -64,33 +64,33 @@ class Table(DbObject):
 
     @property
     def identity_enabled(self) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         return self.get_property("delta.feature.identityColumns") == "supported"
 
     @property
     def type_widening_enabled(self) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         return self.get_property("delta.enableTypeWidening") == "true"
 
     @property
     def liquid_clustering_enabled(self) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         return self.get_property("delta.feature.clustering") == "supported"
 
     @property
     def auto_liquid_clustering_enabled(self) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         return self.get_property("delta.clusterByAuto") == "true"
 
     @property
     def vorder_enabled(self) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         return self.get_property("delta.parquet.vorder.enabled") == "true"
 
     def drop(self):
         super().drop()
         if self.delta_path.exists():
-            DEFAULT_LOGGER.debug("delete delta folder", extra={"job": self})
+            DEFAULT_LOGGER.debug("delete delta folder", extra={"label": self})
             self.delta_path.rm()
 
     @overload
@@ -104,6 +104,10 @@ class Table(DbObject):
         liquid_clustering: Optional[bool] = False,
         cluster_by: Optional[Union[List[str], str]] = None,
         properties: Optional[dict[str, str]] = None,
+        masks: Optional[dict[str, str]] = None,
+        primary_key: Optional[dict[str, Any]] = None,
+        foreign_keys: Optional[dict[str, Any]] = None,
+        comments: Optional[dict[str, str]] = None,
     ): ...
 
     @overload
@@ -117,6 +121,10 @@ class Table(DbObject):
         liquid_clustering: Optional[bool] = False,
         cluster_by: Optional[Union[List[str], str]] = None,
         properties: Optional[dict[str, str]] = None,
+        masks: Optional[dict[str, str]] = None,
+        primary_key: Optional[dict[str, Any]] = None,
+        foreign_keys: Optional[dict[str, Any]] = None,
+        comments: Optional[dict[str, str]] = None,
     ): ...
 
     def create(
@@ -129,6 +137,10 @@ class Table(DbObject):
         liquid_clustering: Optional[bool] = False,
         cluster_by: Optional[Union[List[str], str]] = None,
         properties: Optional[dict[str, str]] = None,
+        masks: Optional[dict[str, str]] = None,
+        primary_key: Optional[dict[str, Any]] = None,
+        foreign_keys: Optional[dict[str, Any]] = None,
+        comments: Optional[dict[str, str]] = None,
     ):
         self._create(
             df=df,
@@ -139,8 +151,41 @@ class Table(DbObject):
             liquid_clustering=liquid_clustering,
             cluster_by=cluster_by,
             properties=properties,
+            masks=masks,
+            primary_key=primary_key,
+            foreign_keys=foreign_keys,
+            comments=comments,
         )
 
+    def _get_ddl_columns(
+        self, df: DataFrame, masks: Optional[dict[str, str]], comments: Optional[dict[str, str]]
+    ) -> List[str]:
+        def _backtick(name: str, dtype: str) -> str:
+            j = df.schema[name].jsonValue()
+            r = re.compile(r"(?<='name': ')[^']+(?=',)")
+
+            names = re.findall(r, str(j))
+            for n in names:
+                escaped = re.escape(n)
+                dtype = re.sub(f"(?<=,){escaped}(?=:)|(?<=<){escaped}(?=:)", f"`{n}`", dtype)
+
+            return dtype
+
+        out = []
+
+        for name, dtype in df.dtypes:
+            col = [f"`{name}`", _backtick(name, dtype)]
+
+            if comments and name in comments:
+                col.append(f"comment '{comments[name]}'")
+
+            if masks and name in masks:
+                col.append(f"mask {masks[name]}")
+
+            out.append(" ".join(col))
+
+        return out
+
     def _create(
         self,
         df: Optional[DataFrame] = None,
@@ -151,26 +196,23 @@ class Table(DbObject):
         liquid_clustering: Optional[bool] = False,
         cluster_by: Optional[Union[List[str], str]] = None,
         properties: Optional[dict[str, str]] = None,
+        masks: Optional[dict[str, str]] = None,
+        primary_key: Optional[dict[str, Any]] = None,
+        foreign_keys: Optional[dict[str, Any]] = None,
+        comments: Optional[dict[str, str]] = None,
     ):
-        DEFAULT_LOGGER.info("create table", extra={"job": self})
+        DEFAULT_LOGGER.info("create table", extra={"label": self})
         if not df:
             assert schema is not None
             df = self.spark.createDataFrame([], schema)
 
-        def _backtick(name: str, dtype: str) -> str:
-            j = df.schema[name].jsonValue()
-            r = re.compile(r"(?<='name': ')[^']+(?=',)")
-            names = re.findall(r, str(j))
-            for n in names:
-                escaped = re.escape(n)
-                dtype = re.sub(f"(?<=,){escaped}(?=:)|(?<=<){escaped}(?=:)", f"`{n}`", dtype)
-            return dtype
-
-        ddl_columns = ",\n\t".join([f"`{name}` {_backtick(name, dtype)}" for name, dtype in df.dtypes])
+        ddl_columns = ",\n\t".join(self._get_ddl_columns(df, masks=masks, comments=comments))
         ddl_identity = "-- no identity" if "__identity" not in df.columns else ""
         ddl_cluster_by = "-- no cluster by"
         ddl_partition_by = "-- no partitioned by"
         ddl_tblproperties = "-- not tblproperties"
+        ddl_primary_key = "-- no primary key"
+        ddl_foreign_keys = "-- no foreign keys"
 
         if liquid_clustering:
             if cluster_by:
@@ -192,6 +234,29 @@ class Table(DbObject):
         if identity:
             ddl_identity = "__identity bigint generated by default as identity (start with 1 increment by 1), "
 
+        if primary_key:
+            assert len(primary_key) == 1, "only one primary key allowed"
+
+            for key, value in primary_key.items():
+                keys = value["keys"]
+                if isinstance(keys, str):
+                    keys = [keys]
+                ddl_primary_key = f", constraint {key} primary key (" + ", ".join(keys) + ")"
+
+        if foreign_keys:
+            fks = []
+
+            for key, value in foreign_keys.items():
+                reference = value["reference"]
+                keys = value["keys"]
+                if isinstance(keys, str):
+                    keys = [keys]
+                keys = ", ".join([f"`{k}`" for k in keys])
+                fk = f"constraint {key} foreign key ({keys}) references {reference}"
+                fks.append(fk)
+
+            ddl_foreign_keys = "," + ", ".join(fks)
+
         if not properties:
             special_char = False
 
@@ -218,6 +283,8 @@ class Table(DbObject):
         (
         {ddl_identity}
         {ddl_columns}
+        {ddl_foreign_keys}
+        {ddl_primary_key}
         )
         {ddl_tblproperties}
         {ddl_partition_by}
@@ -229,7 +296,7 @@ class Table(DbObject):
         except Exception:
             pass
 
-        DEFAULT_LOGGER.debug("ddl", extra={"job": self, "sql": sql})
+        DEFAULT_LOGGER.debug("ddl", extra={"label": self, "sql": sql})
         self.spark.sql(sql)
 
     @property
@@ -238,38 +305,40 @@ class Table(DbObject):
 
     @property
     def column_mapping_enabled(self) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.get_property("delta.columnMapping.mode") == "name"
 
     def exists(self) -> bool:
-        return self.is_deltatable and self.is_registered
+        return self.is_deltatable and self.registered
 
     def register(self):
-        DEFAULT_LOGGER.debug("register table", extra={"job": self})
+        DEFAULT_LOGGER.debug("register table", extra={"label": self})
         self.spark.sql(f"create table if not exists {self.qualified_name} using delta location '{self.delta_path}'")
 
     def restore_to_version(self, version: int):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.info(f"restore table to version {version}", extra={"job": self})
+        DEFAULT_LOGGER.info(f"restore table to version {version}", extra={"label": self})
         self.spark.sql(f"restore table {self.qualified_name} to version as of {version}")
 
     def truncate(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.warning("truncate table", extra={"job": self})
+        DEFAULT_LOGGER.warning("truncate table", extra={"label": self})
         self.create_restore_point()
         self.spark.sql(f"truncate table {self.qualified_name}")
 
     def schema_drifted(self, df: DataFrame, exclude_columns_with_prefix: Optional[str] = None) -> bool:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         diffs = self.get_schema_differences(df)
         return len(diffs) > 0
 
     def get_schema_differences(self, df: DataFrame) -> Sequence[SchemaDiff]:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
+
+        DEFAULT_LOGGER.debug("get schema differences", extra={"label": self, "df": df})
 
         df1 = self.dataframe
         if self.identity_enabled:
@@ -305,12 +374,12 @@ class Table(DbObject):
                 )
 
         if diffs:
-            DEFAULT_LOGGER.debug("difference(s) with delta table", extra={"job": self, "df": df})
+            DEFAULT_LOGGER.warning("difference(s) with delta table", extra={"label": self, "df": df})
 
         return diffs
 
     def update_schema(self, df: DataFrame, widen_types: bool = False):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         if not self.column_mapping_enabled:
             self.enable_column_mapping()
 
@@ -323,7 +392,7 @@ class Table(DbObject):
             msg = "update schema"
 
         if diffs:
-            DEFAULT_LOGGER.info(msg, extra={"job": self, "df": diffs})
+            DEFAULT_LOGGER.info(msg, extra={"label": self, "df": diffs})
 
             for row in diffs:
                 if row.status == "changed":
@@ -333,7 +402,7 @@ class Table(DbObject):
 
                 DEFAULT_LOGGER.debug(
                     f"{row.status.replace('ed', 'ing')} {row.column} ({data_type})",
-                    extra={"job": self},
+                    extra={"label": self},
                 )
 
                 try:
@@ -360,7 +429,7 @@ class Table(DbObject):
                     pass
 
     def overwrite_schema(self, df: DataFrame):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         if not self.column_mapping_enabled:
             self.enable_column_mapping()
 
@@ -371,7 +440,7 @@ class Table(DbObject):
 
         diffs = self.get_schema_differences(df)
         if diffs:
-            DEFAULT_LOGGER.warning("overwrite schema", extra={"job": self, "df": diffs})
+            DEFAULT_LOGGER.warning("overwrite schema", extra={"label": self, "df": diffs})
 
             for row in diffs:
                 if row.status == "added":
@@ -391,9 +460,9 @@ class Table(DbObject):
                         self.add_column(row.column, row.new_data_type)
 
     def vacuum(self, retention_days: int = 7):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug(f"vacuum table (removing files older than {retention_days} days)", extra={"job": self})
+        DEFAULT_LOGGER.debug(f"vacuum table (removing files older than {retention_days} days)", extra={"label": self})
         self.spark.sql("SET self.spark.databricks.delta.retentionDurationCheck.enabled = False")
         try:
             self.create_restore_point()
@@ -405,9 +474,9 @@ class Table(DbObject):
         self.spark.sql("SET self.spark.databricks.delta.retentionDurationCheck.enabled = True")
 
     def optimize(self, columns: Optional[Union[str, List[str]]] = None):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.info("optimize", extra={"job": self})
+        DEFAULT_LOGGER.info("optimize", extra={"label": self})
 
         if self.liquid_clustering_enabled:
             self.spark.sql(f"optimize {self.qualified_name}")
@@ -417,7 +486,7 @@ class Table(DbObject):
 
         elif columns is None:
             if self.vorder_enabled:
-                DEFAULT_LOGGER.debug("vorder", extra={"job": self})
+                DEFAULT_LOGGER.debug("vorder", extra={"label": self})
                 self.spark.sql(f"optimize {self.qualified_name} vorder")
             else:
                 self.spark.sql(f"optimize {self.qualified_name}")
@@ -429,24 +498,24 @@ class Table(DbObject):
             cols = ", ".join(columns)
 
             if self.vorder_enabled:
-                DEFAULT_LOGGER.debug(f"zorder by {cols} vorder", extra={"job": self})
+                DEFAULT_LOGGER.debug(f"zorder by {cols} vorder", extra={"label": self})
                 self.spark.sql(f"optimize {self.qualified_name} zorder by ({cols}) vorder")
 
             else:
-                DEFAULT_LOGGER.debug(f"zorder by {cols}", extra={"job": self})
+                DEFAULT_LOGGER.debug(f"zorder by {cols}", extra={"label": self})
                 self.spark.sql(f"optimize {self.qualified_name} zorder by ({cols})")
 
     def analyze(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug("analyze", extra={"job": self})
+        DEFAULT_LOGGER.debug("analyze", extra={"label": self})
         self.compute_statistics()
         self.compute_delta_statistics()
 
     def compute_statistics(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug("compute statistics", extra={"job": self})
+        DEFAULT_LOGGER.debug("compute statistics", extra={"label": self})
         cols = [
             f"`{name}`"
             for name, dtype in self.dataframe.dtypes
@@ -460,16 +529,16 @@ class Table(DbObject):
         self.spark.sql(f"analyze table {self.qualified_name} compute statistics for columns {cols}")
 
     def compute_delta_statistics(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug("compute delta statistics", extra={"job": self})
+        DEFAULT_LOGGER.debug("compute delta statistics", extra={"label": self})
         self.spark.sql(f"analyze table {self.qualified_name} compute delta statistics")
 
     def drop_column(self, name: str):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         assert self.column_mapping_enabled, "column mapping not enabled"
 
-        DEFAULT_LOGGER.warning(f"drop column {name}", extra={"job": self})
+        DEFAULT_LOGGER.warning(f"drop column {name}", extra={"label": self})
         self.spark.sql(
             f"""
             alter table {self.qualified_name}
@@ -478,10 +547,10 @@ class Table(DbObject):
         )
 
     def change_column(self, name: str, type: str):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         assert self.column_mapping_enabled, "column mapping not enabled"
 
-        DEFAULT_LOGGER.info(f"change column {name} ({type})", extra={"job": self})
+        DEFAULT_LOGGER.info(f"change column {name} ({type})", extra={"label": self})
         self.spark.sql(
             f"""
             alter table {self.qualified_name}
@@ -490,10 +559,10 @@ class Table(DbObject):
         )
 
     def rename_column(self, old: str, new: str):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         assert self.column_mapping_enabled, "column mapping not enabled"
 
-        DEFAULT_LOGGER.info(f"rename column {old} -> {new}", extra={"job": self})
+        DEFAULT_LOGGER.info(f"rename column {old} -> {new}", extra={"label": self})
         self.spark.sql(
             f"""
             alter table {self.qualified_name}
@@ -506,35 +575,35 @@ class Table(DbObject):
         return data_type
 
     def get_details(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"describe detail {self.qualified_name}")
 
     def get_properties(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"show tblproperties {self.qualified_name}")
 
     def get_description(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"describe extended {self.qualified_name}")
 
     def get_history(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         df = self.spark.sql(f"describe history {self.qualified_name}")
         return df
 
     def get_last_version(self) -> int:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         df = self.get_history()
         version = df.select(max("version")).collect()[0][0]
         return version
 
     def get_property(self, key: str) -> Optional[str]:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         try:
             value = self.get_properties().where(f"key == '{key}'").select("value").collect()[0][0]
@@ -544,15 +613,15 @@ class Table(DbObject):
             return None
 
     def enable_change_data_feed(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug("enable change data feed", extra={"job": self})
+        DEFAULT_LOGGER.debug("enable change data feed", extra={"label": self})
         self.set_property("delta.enableChangeDataFeed", "true")
 
     def enable_column_mapping(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug("enable column mapping", extra={"job": self})
+        DEFAULT_LOGGER.debug("enable column mapping", extra={"label": self})
 
         try:
             self.spark.sql(
@@ -563,7 +632,7 @@ class Table(DbObject):
             )
 
         except Exception:
-            DEFAULT_LOGGER.debug("update reader and writer version", extra={"job": self})
+            DEFAULT_LOGGER.debug("update reader and writer version", extra={"label": self})
             self.spark.sql(
                 f"""
                 alter table {self.qualified_name} 
@@ -576,9 +645,9 @@ class Table(DbObject):
             )
 
     def set_property(self, key: Union[str, int], value: Union[str, int]):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug(f"set property {key} = {value}", extra={"job": self})
+        DEFAULT_LOGGER.debug(f"set property {key} = {value}", extra={"label": self})
         self.spark.sql(
             f"""
             alter table {self.qualified_name}
@@ -587,9 +656,9 @@ class Table(DbObject):
         )
 
     def add_constraint(self, name: str, expr: str):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug(f"add constraint ({name} check ({expr}))", extra={"job": self})
+        DEFAULT_LOGGER.debug(f"add constraint ({name} check ({expr}))", extra={"label": self})
         self.spark.sql(
             f"""
             alter table {self.qualified_name}
@@ -598,9 +667,9 @@ class Table(DbObject):
         )
 
     def add_comment(self, comment: str):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.debug(f"add comment '{comment}'", extra={"job": self})
+        DEFAULT_LOGGER.debug(f"add comment '{comment}'", extra={"label": self})
         self.spark.sql(
             f"""
             comment on table {self.qualified_name}
@@ -609,10 +678,10 @@ class Table(DbObject):
         )
 
     def add_materialized_column(self, name: str, expr: str, type: str):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
         assert self.column_mapping_enabled, "column mapping not enabled"
 
-        DEFAULT_LOGGER.info(f"add materialized column ({name} {type})", extra={"job": self})
+        DEFAULT_LOGGER.info(f"add materialized column ({name} {type})", extra={"label": self})
         self.spark.sql(
             f""""
             alter table {self.qualified_name}
@@ -621,9 +690,9 @@ class Table(DbObject):
         )
 
     def add_column(self, name: str, type: str, after: Optional[str] = None):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
-        DEFAULT_LOGGER.info(f"add column {name} ({type})", extra={"job": self})
+        DEFAULT_LOGGER.info(f"add column {name} ({type})", extra={"label": self})
         ddl_after = "" if not after else f"after {after}"
         self.spark.sql(
             f"""
@@ -633,14 +702,14 @@ class Table(DbObject):
         )
 
     def create_bloomfilter_index(self, columns: Union[str, List[str]]):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         if isinstance(columns, str):
             columns = [columns]
         columns = [f"`{c}`" for c in columns]
         cols = ", ".join(columns)
 
-        DEFAULT_LOGGER.info(f"bloomfilter by {cols}", extra={"job": self})
+        DEFAULT_LOGGER.info(f"bloomfilter by {cols}", extra={"label": self})
         self.spark.sql(
             f"""
             create bloomfilter index on table {self.qualified_name}
@@ -649,37 +718,37 @@ class Table(DbObject):
         )
 
     def create_restore_point(self):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         last_version = self.get_last_version() + 1
         self.set_property("fabricks.last_version", last_version)
 
     def show_properties(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"show tblproperties {self.qualified_name}")
 
     def describe_detail(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"describe detail {self.qualified_name}")
 
     def describe_extended(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         return self.spark.sql(f"describe extended {self.qualified_name}")
 
     def describe_history(self) -> DataFrame:
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         df = self.spark.sql(f"describe history {self.qualified_name}")
         return df
 
     def enable_liquid_clustering(self, columns: Optional[Union[str, List[str]]] = None, auto: Optional[bool] = False):
-        assert self.is_registered, f"{self} not registered"
+        assert self.registered, f"{self} not registered"
 
         if auto:
-            DEFAULT_LOGGER.info("cluster by auto", extra={"job": self})
+            DEFAULT_LOGGER.info("cluster by auto", extra={"label": self})
             self.spark.sql(f"alter table {self.qualified_name} cluster by automatic")
 
         else:
@@ -690,7 +759,7 @@ class Table(DbObject):
             columns = [f"`{c}`" for c in columns]
             cols = ", ".join(columns)
 
-            DEFAULT_LOGGER.info(f"cluster by {cols}", extra={"job": self})
+            DEFAULT_LOGGER.info(f"cluster by {cols}", extra={"label": self})
             self.spark.sql(
                 f"""
                 alter table {self.qualified_name}