apache-airflow-providers-openlineage 1.9.1rc1__py3-none-any.whl → 1.10.0__py3-none-any.whl

airflow/providers/openlineage/plugins/adapter.py

@@ -22,24 +22,25 @@ from typing import TYPE_CHECKING
 
 import yaml
 from openlineage.client import OpenLineageClient, set_producer
-from openlineage.client.facet import (
-    BaseFacet,
-    DocumentationJobFacet,
-    ErrorMessageRunFacet,
-    JobTypeJobFacet,
-    NominalTimeRunFacet,
-    OwnershipJobFacet,
-    OwnershipJobFacetOwners,
-    ParentRunFacet,
-    ProcessingEngineRunFacet,
-    SourceCodeLocationJobFacet,
+from openlineage.client.event_v2 import Job, Run, RunEvent, RunState
+from openlineage.client.facet_v2 import (
+    JobFacet,
+    RunFacet,
+    documentation_job,
+    error_message_run,
+    job_type_job,
+    nominal_time_run,
+    ownership_job,
+    parent_run,
+    processing_engine_run,
+    source_code_location_job,
 )
-from openlineage.client.run import Job, Run, RunEvent, RunState
 from openlineage.client.uuid import generate_static_uuid
 
 from airflow.providers.openlineage import __version__ as OPENLINEAGE_PROVIDER_VERSION, conf
 from airflow.providers.openlineage.utils.utils import (
     OpenLineageRedactor,
+    get_airflow_dag_run_facet,
     get_airflow_state_run_facet,
 )
 from airflow.stats import Stats
@@ -59,8 +60,8 @@ set_producer(_PRODUCER)
 # https://openlineage.io/docs/spec/facets/job-facets/job-type
 # They must be set after the `set_producer(_PRODUCER)`
 # otherwise the `JobTypeJobFacet._producer` will be set with the default value
-_JOB_TYPE_DAG = JobTypeJobFacet(jobType="DAG", integration="AIRFLOW", processingType="BATCH")
-_JOB_TYPE_TASK = JobTypeJobFacet(jobType="TASK", integration="AIRFLOW", processingType="BATCH")
+_JOB_TYPE_DAG = job_type_job.JobTypeJobFacet(jobType="DAG", integration="AIRFLOW", processingType="BATCH")
+_JOB_TYPE_TASK = job_type_job.JobTypeJobFacet(jobType="TASK", integration="AIRFLOW", processingType="BATCH")
 
 
 class OpenLineageAdapter(LoggingMixin):
@@ -148,7 +149,7 @@ class OpenLineageAdapter(LoggingMixin):
         if not self._client:
             self._client = self.get_or_create_openlineage_client()
         redacted_event: RunEvent = self._redacter.redact(event, max_depth=20)  # type: ignore[assignment]
-        event_type = event.eventType.value.lower()
+        event_type = event.eventType.value.lower() if event.eventType else ""
         transport_type = f"{self._client.transport.kind}".lower()
 
         try:
@@ -177,7 +178,7 @@ class OpenLineageAdapter(LoggingMixin):
         nominal_end_time: str | None,
         owners: list[str],
         task: OperatorLineage | None,
-        run_facets: dict[str, BaseFacet] | None = None,  # Custom run facets
+        run_facets: dict[str, RunFacet] | None = None,
     ) -> RunEvent:
         """
         Emit openlineage event of type START.
@@ -198,14 +199,13 @@ class OpenLineageAdapter(LoggingMixin):
         """
         from airflow.version import version as AIRFLOW_VERSION
 
-        processing_engine_version_facet = ProcessingEngineRunFacet(
+        processing_engine_version_facet = processing_engine_run.ProcessingEngineRunFacet(
             version=AIRFLOW_VERSION,
             name="Airflow",
             openlineageAdapterVersion=OPENLINEAGE_PROVIDER_VERSION,
         )
 
-        if not run_facets:
-            run_facets = {}
+        run_facets = run_facets or {}
         if task:
             run_facets = {**task.run_facets, **run_facets}
         run_facets["processing_engine"] = processing_engine_version_facet  # type: ignore
@@ -243,6 +243,7 @@ class OpenLineageAdapter(LoggingMixin):
         parent_run_id: str | None,
         end_time: str,
         task: OperatorLineage,
+        run_facets: dict[str, RunFacet] | None = None,
     ) -> RunEvent:
         """
         Emit openlineage event of type COMPLETE.
@@ -254,7 +255,11 @@ class OpenLineageAdapter(LoggingMixin):
         :param parent_run_id: identifier of job spawning this task
         :param end_time: time of task completion
         :param task: metadata container with information extracted from operator
+        :param run_facets: additional run facets
         """
+        run_facets = run_facets or {}
+        if task:
+            run_facets = {**task.run_facets, **run_facets}
         event = RunEvent(
             eventType=RunState.COMPLETE,
             eventTime=end_time,
@@ -263,7 +268,7 @@ class OpenLineageAdapter(LoggingMixin):
                 job_name=job_name,
                 parent_job_name=parent_job_name,
                 parent_run_id=parent_run_id,
-                run_facets=task.run_facets,
+                run_facets=run_facets,
             ),
             job=self._build_job(job_name, job_type=_JOB_TYPE_TASK, job_facets=task.job_facets),
             inputs=task.inputs,
@@ -281,6 +286,7 @@ class OpenLineageAdapter(LoggingMixin):
         end_time: str,
         task: OperatorLineage,
         error: str | BaseException | None = None,
+        run_facets: dict[str, RunFacet] | None = None,
     ) -> RunEvent:
         """
         Emit openlineage event of type FAIL.
@@ -292,21 +298,23 @@ class OpenLineageAdapter(LoggingMixin):
         :param parent_run_id: identifier of job spawning this task
         :param end_time: time of task completion
         :param task: metadata container with information extracted from operator
+        :param run_facets: custom run facets
         :param error: error
+        :param run_facets: additional run facets
         """
-        error_facet = {}
+        run_facets = run_facets or {}
+        if task:
+            run_facets = {**task.run_facets, **run_facets}
+
         if error:
             stack_trace = None
             if isinstance(error, BaseException) and error.__traceback__:
                 import traceback
 
                 stack_trace = "\\n".join(traceback.format_exception(type(error), error, error.__traceback__))
-
-            error_facet = {
-                "errorMessage": ErrorMessageRunFacet(
-                    message=str(error), programmingLanguage="python", stackTrace=stack_trace
-                )
-            }
+            run_facets["errorMessage"] = error_message_run.ErrorMessageRunFacet(
+                message=str(error), programmingLanguage="python", stackTrace=stack_trace
+            )
 
         event = RunEvent(
             eventType=RunState.FAIL,
@@ -316,7 +324,7 @@ class OpenLineageAdapter(LoggingMixin):
                 job_name=job_name,
                 parent_job_name=parent_job_name,
                 parent_run_id=parent_run_id,
-                run_facets={**task.run_facets, **error_facet},
+                run_facets=run_facets,
             ),
             job=self._build_job(job_name, job_type=_JOB_TYPE_TASK, job_facets=task.job_facets),
             inputs=task.inputs,
@@ -331,9 +339,10 @@ class OpenLineageAdapter(LoggingMixin):
         msg: str,
         nominal_start_time: str,
         nominal_end_time: str,
-        job_facets: dict[str, BaseFacet] | None = None,  # Custom job facets
+        job_facets: dict[str, JobFacet] | None = None,  # Custom job facets
     ):
         try:
+            owner = [x.strip() for x in dag_run.dag.owner.split(",")] if dag_run.dag else None
             event = RunEvent(
                 eventType=RunState.START,
                 eventTime=dag_run.start_date.isoformat(),
@@ -341,7 +350,7 @@ class OpenLineageAdapter(LoggingMixin):
                     job_name=dag_run.dag_id,
                     job_type=_JOB_TYPE_DAG,
                     job_description=dag_run.dag.description if dag_run.dag else None,
-                    owners=[x.strip() for x in dag_run.dag.owner.split(",")] if dag_run.dag else None,
+                    owners=owner,
                     job_facets=job_facets,
                 ),
                 run=self._build_run(
@@ -352,6 +361,7 @@ class OpenLineageAdapter(LoggingMixin):
                     job_name=dag_run.dag_id,
                     nominal_start_time=nominal_start_time,
                     nominal_end_time=nominal_end_time,
+                    run_facets=get_airflow_dag_run_facet(dag_run),
                 ),
                 inputs=[],
                 outputs=[],
@@ -400,7 +410,9 @@ class OpenLineageAdapter(LoggingMixin):
                         execution_date=dag_run.execution_date,
                     ),
                     facets={
-                        "errorMessage": ErrorMessageRunFacet(message=msg, programmingLanguage="python"),
+                        "errorMessage": error_message_run.ErrorMessageRunFacet(
+                            message=msg, programmingLanguage="python"
+                        ),
                         **get_airflow_state_run_facet(dag_run),
                     },
                 ),
@@ -423,23 +435,19 @@ class OpenLineageAdapter(LoggingMixin):
         parent_run_id: str | None = None,
         nominal_start_time: str | None = None,
         nominal_end_time: str | None = None,
-        run_facets: dict[str, BaseFacet] | None = None,
+        run_facets: dict[str, RunFacet] | None = None,
     ) -> Run:
-        facets: dict[str, BaseFacet] = {}
+        facets: dict[str, RunFacet] = {}
         if nominal_start_time:
-            facets.update({"nominalTime": NominalTimeRunFacet(nominal_start_time, nominal_end_time)})
-        if parent_run_id:
-            parent_run_facet = ParentRunFacet.create(
-                runId=parent_run_id,
-                namespace=conf.namespace(),
-                name=parent_job_name or job_name,
-            )
             facets.update(
-                {
-                    "parent": parent_run_facet,
-                    "parentRun": parent_run_facet,  # Keep sending this for the backward compatibility
-                }
+                {"nominalTime": nominal_time_run.NominalTimeRunFacet(nominal_start_time, nominal_end_time)}
             )
+        if parent_run_id:
+            parent_run_facet = parent_run.ParentRunFacet(
+                run=parent_run.Run(runId=parent_run_id),
+                job=parent_run.Job(namespace=conf.namespace(), name=parent_job_name or job_name),
+            )
+            facets.update({"parent": parent_run_facet})
 
         if run_facets:
             facets.update(run_facets)
@@ -449,23 +457,31 @@ class OpenLineageAdapter(LoggingMixin):
     @staticmethod
     def _build_job(
         job_name: str,
-        job_type: JobTypeJobFacet,
+        job_type: job_type_job.JobTypeJobFacet,
         job_description: str | None = None,
         code_location: str | None = None,
         owners: list[str] | None = None,
-        job_facets: dict[str, BaseFacet] | None = None,
+        job_facets: dict[str, JobFacet] | None = None,
     ):
-        facets: dict[str, BaseFacet] = {}
+        facets: dict[str, JobFacet] = {}
 
         if job_description:
-            facets.update({"documentation": DocumentationJobFacet(description=job_description)})
+            facets.update(
+                {"documentation": documentation_job.DocumentationJobFacet(description=job_description)}
+            )
         if code_location:
-            facets.update({"sourceCodeLocation": SourceCodeLocationJobFacet("", url=code_location)})
+            facets.update(
+                {
+                    "sourceCodeLocation": source_code_location_job.SourceCodeLocationJobFacet(
+                        "", url=code_location
+                    )
+                }
+            )
         if owners:
             facets.update(
                 {
-                    "ownership": OwnershipJobFacet(
-                        owners=[OwnershipJobFacetOwners(name=owner) for owner in owners]
+                    "ownership": ownership_job.OwnershipJobFacet(
+                        owners=[ownership_job.Owner(name=owner) for owner in owners]
                     )
                 }
             )

airflow/providers/openlineage/plugins/facets.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 from attrs import define
 from deprecated import deprecated
-from openlineage.client.facet import BaseFacet
+from openlineage.client.facet_v2 import JobFacet, RunFacet
 from openlineage.client.utils import RedactMixin
 
 from airflow.exceptions import AirflowProviderDeprecationWarning
@@ -28,8 +28,8 @@ from airflow.exceptions import AirflowProviderDeprecationWarning
     reason="To be removed in the next release. Make sure to use information from AirflowRunFacet instead.",
     category=AirflowProviderDeprecationWarning,
 )
-@define(slots=False)
-class AirflowMappedTaskRunFacet(BaseFacet):
+@define
+class AirflowMappedTaskRunFacet(RunFacet):
     """Run facet containing information about mapped tasks."""
 
     mapIndex: int
@@ -47,8 +47,8 @@ class AirflowMappedTaskRunFacet(BaseFacet):
         )
 
 
-@define(slots=False)
-class AirflowJobFacet(BaseFacet):
+@define
+class AirflowJobFacet(JobFacet):
     """
     Composite Airflow job facet.
 
@@ -70,8 +70,8 @@ class AirflowJobFacet(BaseFacet):
     tasks: dict
 
 
-@define(slots=False)
-class AirflowStateRunFacet(BaseFacet):
+@define
+class AirflowStateRunFacet(RunFacet):
     """
     Airflow facet providing state information.
 
@@ -89,8 +89,8 @@ class AirflowStateRunFacet(BaseFacet):
     tasksState: dict[str, str]
 
 
-@define(slots=False)
-class AirflowRunFacet(BaseFacet):
+@define
+class AirflowRunFacet(RunFacet):
     """Composite Airflow run facet."""
 
     dag: dict
@@ -100,7 +100,15 @@ class AirflowRunFacet(BaseFacet):
     taskUuid: str
 
 
-@define(slots=False)
+@define
+class AirflowDagRunFacet(RunFacet):
+    """Composite Airflow DAG run facet."""
+
+    dag: dict
+    dagRun: dict
+
+
+@define
 class UnknownOperatorInstance(RedactMixin):
     """
     Describes an unknown operator.
@@ -119,8 +127,8 @@ class UnknownOperatorInstance(RedactMixin):
     reason="To be removed in the next release. Make sure to use information from AirflowRunFacet instead.",
     category=AirflowProviderDeprecationWarning,
 )
-@define(slots=False)
-class UnknownOperatorAttributeRunFacet(BaseFacet):
+@define
+class UnknownOperatorAttributeRunFacet(RunFacet):
     """RunFacet that describes unknown operators in an Airflow DAG."""
 
     unknownItems: list[UnknownOperatorInstance]

airflow/providers/openlineage/plugins/listener.py

@@ -19,45 +19,45 @@ from __future__ import annotations
 import logging
 import os
 from concurrent.futures import ProcessPoolExecutor
-from datetime import datetime
 from typing import TYPE_CHECKING
 
 import psutil
 from openlineage.client.serde import Serde
-from packaging.version import Version
 from setproctitle import getproctitle, setproctitle
 
-from airflow import __version__ as AIRFLOW_VERSION, settings
+from airflow import settings
 from airflow.listeners import hookimpl
 from airflow.providers.openlineage import conf
 from airflow.providers.openlineage.extractors import ExtractorManager
 from airflow.providers.openlineage.plugins.adapter import OpenLineageAdapter, RunState
 from airflow.providers.openlineage.utils.utils import (
+    IS_AIRFLOW_2_10_OR_HIGHER,
     get_airflow_job_facet,
+    get_airflow_mapped_task_facet,
     get_airflow_run_facet,
-    get_custom_facets,
     get_job_name,
+    get_user_provided_run_facets,
     is_operator_disabled,
     is_selective_lineage_enabled,
     print_warning,
 )
 from airflow.settings import configure_orm
 from airflow.stats import Stats
+from airflow.utils import timezone
+from airflow.utils.state import TaskInstanceState
 from airflow.utils.timeout import timeout
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
     from airflow.models import DagRun, TaskInstance
-    from airflow.utils.state import TaskInstanceState
 
 _openlineage_listener: OpenLineageListener | None = None
-_IS_AIRFLOW_2_10_OR_HIGHER = Version(Version(AIRFLOW_VERSION).base_version) >= Version("2.10.0")
 
 
 def _get_try_number_success(val):
     # todo: remove when min airflow version >= 2.10.0
-    if _IS_AIRFLOW_2_10_OR_HIGHER:
+    if IS_AIRFLOW_2_10_OR_HIGHER:
         return val.try_number
     return val.try_number - 1
 
@@ -145,7 +145,7 @@ class OpenLineageListener:
             with Stats.timer(f"ol.extract.{event_type}.{operator_name}"):
                 task_metadata = self.extractor_manager.extract_metadata(dagrun, task)
 
-            start_date = task_instance.start_date if task_instance.start_date else datetime.now()
+            start_date = task_instance.start_date if task_instance.start_date else timezone.utcnow()
             data_interval_start = (
                 dagrun.data_interval_start.isoformat() if dagrun.data_interval_start else None
             )
@@ -163,7 +163,8 @@ class OpenLineageListener:
                 owners=dag.owner.split(", "),
                 task=task_metadata,
                 run_facets={
-                    **get_custom_facets(task_instance),
+                    **get_user_provided_run_facets(task_instance, TaskInstanceState.RUNNING),
+                    **get_airflow_mapped_task_facet(task_instance),
                     **get_airflow_run_facet(dagrun, dag, task_instance, task, task_uuid),
                 },
             )
@@ -224,7 +225,7 @@ class OpenLineageListener:
                     dagrun, task, complete=True, task_instance=task_instance
                 )
 
-            end_date = task_instance.end_date if task_instance.end_date else datetime.now()
+            end_date = task_instance.end_date if task_instance.end_date else timezone.utcnow()
 
             redacted_event = self.adapter.complete_task(
                 run_id=task_uuid,
@@ -233,6 +234,10 @@ class OpenLineageListener:
                 parent_run_id=parent_run_id,
                 end_time=end_date.isoformat(),
                 task=task_metadata,
+                run_facets={
+                    **get_user_provided_run_facets(task_instance, TaskInstanceState.SUCCESS),
+                    **get_airflow_run_facet(dagrun, dag, task_instance, task, task_uuid),
+                },
             )
             Stats.gauge(
                 f"ol.event.size.{event_type}.{operator_name}",
@@ -241,7 +246,7 @@ class OpenLineageListener:
 
         self._execute(on_success, "on_success", use_fork=True)
 
-    if _IS_AIRFLOW_2_10_OR_HIGHER:
+    if IS_AIRFLOW_2_10_OR_HIGHER:
 
         @hookimpl
         def on_task_instance_failed(
@@ -318,7 +323,7 @@ class OpenLineageListener:
                     dagrun, task, complete=True, task_instance=task_instance
                 )
 
-            end_date = task_instance.end_date if task_instance.end_date else datetime.now()
+            end_date = task_instance.end_date if task_instance.end_date else timezone.utcnow()
 
             redacted_event = self.adapter.fail_task(
                 run_id=task_uuid,
@@ -328,6 +333,10 @@ class OpenLineageListener:
                 end_time=end_date.isoformat(),
                 task=task_metadata,
                 error=error,
+                run_facets={
+                    **get_user_provided_run_facets(task_instance, TaskInstanceState.FAILED),
+                    **get_airflow_run_facet(dagrun, dag, task_instance, task, task_uuid),
+                },
             )
             Stats.gauge(
                 f"ol.event.size.{event_type}.{operator_name}",
@@ -420,7 +429,7 @@ class OpenLineageListener:
             nominal_end_time=data_interval_end,
             # AirflowJobFacet should be created outside ProcessPoolExecutor that pickles objects,
             # as it causes lack of some TaskGroup attributes and crashes event emission.
-            job_facets={**get_airflow_job_facet(dag_run=dag_run)},
+            job_facets=get_airflow_job_facet(dag_run=dag_run),
         )
 
     @hookimpl

airflow/providers/openlineage/sqlparser.py

@@ -20,16 +20,8 @@ from typing import TYPE_CHECKING, Callable
 
 import sqlparse
 from attrs import define
-from openlineage.client.facet import (
-    BaseFacet,
-    ColumnLineageDatasetFacet,
-    ColumnLineageDatasetFacetFieldsAdditional,
-    ColumnLineageDatasetFacetFieldsAdditionalInputFields,
-    ExtractionError,
-    ExtractionErrorRunFacet,
-    SqlJobFacet,
-)
-from openlineage.client.run import Dataset
+from openlineage.client.event_v2 import Dataset
+from openlineage.client.facet_v2 import column_lineage_dataset, extraction_error_run, sql_job
 from openlineage.common.sql import DbTableMeta, SqlMeta, parse
 
 from airflow.providers.openlineage.extractors.base import OperatorLineage
@@ -42,6 +34,7 @@ from airflow.typing_compat import TypedDict
 from airflow.utils.log.logging_mixin import LoggingMixin
 
 if TYPE_CHECKING:
+    from openlineage.client.facet_v2 import JobFacet, RunFacet
     from sqlalchemy.engine import Engine
 
     from airflow.hooks.base import BaseHook
@@ -160,7 +153,6 @@ class SQLParser(LoggingMixin):
             "database": database or database_info.database,
             "use_flat_cross_db_query": database_info.use_flat_cross_db_query,
         }
-        self.log.info("PRE getting schemas for input and output tables")
         return get_table_schemas(
             hook,
             namespace,
@@ -207,11 +199,12 @@ class SQLParser(LoggingMixin):
         if not len(parse_result.column_lineage):
             return
         for dataset in datasets:
-            dataset.facets["columnLineage"] = ColumnLineageDatasetFacet(
+            dataset.facets = dataset.facets or {}
+            dataset.facets["columnLineage"] = column_lineage_dataset.ColumnLineageDatasetFacet(
                 fields={
-                    column_lineage.descendant.name: ColumnLineageDatasetFacetFieldsAdditional(
+                    column_lineage.descendant.name: column_lineage_dataset.Fields(
                         inputFields=[
-                            ColumnLineageDatasetFacetFieldsAdditionalInputFields(
+                            column_lineage_dataset.InputField(
                                 namespace=dataset.namespace,
                                 name=".".join(
                                     filter(
@@ -261,18 +254,18 @@ class SQLParser(LoggingMixin):
         :param database: when passed it takes precedence over parsed database name
         :param sqlalchemy_engine: when passed, engine's dialect is used to compile SQL queries
         """
-        job_facets: dict[str, BaseFacet] = {"sql": SqlJobFacet(query=self.normalize_sql(sql))}
-        parse_result = self.parse(self.split_sql_string(sql))
+        job_facets: dict[str, JobFacet] = {"sql": sql_job.SQLJobFacet(query=self.normalize_sql(sql))}
+        parse_result = self.parse(sql=self.split_sql_string(sql))
         if not parse_result:
             return OperatorLineage(job_facets=job_facets)
 
-        run_facets: dict[str, BaseFacet] = {}
+        run_facets: dict[str, RunFacet] = {}
         if parse_result.errors:
-            run_facets["extractionError"] = ExtractionErrorRunFacet(
+            run_facets["extractionError"] = extraction_error_run.ExtractionErrorRunFacet(
                 totalTasks=len(sql) if isinstance(sql, list) else 1,
                 failedTasks=len(parse_result.errors),
                 errors=[
-                    ExtractionError(
+                    extraction_error_run.Error(
                         errorMessage=error.message,
                         stackTrace=None,
                         task=error.origin_statement,

airflow/providers/openlineage/utils/sql.py

@@ -23,8 +23,8 @@ from enum import IntEnum
 from typing import TYPE_CHECKING, Dict, List, Optional
 
 from attrs import define
-from openlineage.client.facet import SchemaDatasetFacet, SchemaField
-from openlineage.client.run import Dataset
+from openlineage.client.event_v2 import Dataset
+from openlineage.client.facet_v2 import schema_dataset
 from sqlalchemy import Column, MetaData, Table, and_, or_, union_all
 
 if TYPE_CHECKING:
@@ -60,7 +60,7 @@ class TableSchema:
     table: str
     schema: str | None
     database: str | None
-    fields: list[SchemaField]
+    fields: list[schema_dataset.SchemaDatasetFacetFields]
 
     def to_dataset(self, namespace: str, database: str | None = None, schema: str | None = None) -> Dataset:
         # Prefix the table name with database and schema name using
@@ -73,7 +73,7 @@ class TableSchema:
         return Dataset(
             namespace=namespace,
             name=name,
-            facets={"schema": SchemaDatasetFacet(fields=self.fields)} if self.fields else {},
+            facets={"schema": schema_dataset.SchemaDatasetFacet(fields=self.fields)} if self.fields else {},
         )
 
 
@@ -122,7 +122,7 @@ def parse_query_result(cursor) -> list[TableSchema]:
     for row in cursor.fetchall():
         table_schema_name: str = row[ColumnIndex.SCHEMA]
         table_name: str = row[ColumnIndex.TABLE_NAME]
-        table_column: SchemaField = SchemaField(
+        table_column = schema_dataset.SchemaDatasetFacetFields(
             name=row[ColumnIndex.COLUMN_NAME],
             type=row[ColumnIndex.UDT_NAME],
             description=None,