acryl-datahub 1.2.0.7rc4__py3-none-any.whl → 1.2.0.8rc2__py3-none-any.whl

datahub/ingestion/source/sql/athena.py

@@ -73,6 +73,11 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+# Precompiled regex for SQL identifier validation
+# Athena identifiers can only contain lowercase letters, numbers, underscore, and period (for complex types)
+# Note: Athena automatically converts uppercase to lowercase, but we're being strict for security
+_IDENTIFIER_PATTERN = re.compile(r"^[a-zA-Z0-9_.]+$")
+
 assert STRUCT, "required type modules are not available"
 register_custom_type(STRUCT, RecordTypeClass)
 register_custom_type(MapType, MapTypeClass)
@@ -510,20 +515,76 @@ class AthenaSource(SQLAlchemySource):
             return [schema for schema in schemas if schema == athena_config.database]
         return schemas
 
+    @classmethod
+    def _sanitize_identifier(cls, identifier: str) -> str:
+        """Sanitize SQL identifiers to prevent injection attacks.
+
+        Args:
+            identifier: The SQL identifier to sanitize
+
+        Returns:
+            Sanitized identifier safe for SQL queries
+
+        Raises:
+            ValueError: If identifier contains unsafe characters
+        """
+        if not identifier:
+            raise ValueError("Identifier cannot be empty")
+
+        # Allow only alphanumeric characters, underscores, and periods for identifiers
+        # This matches Athena's identifier naming rules
+        if not _IDENTIFIER_PATTERN.match(identifier):
+            raise ValueError(
+                f"Identifier '{identifier}' contains unsafe characters. Only alphanumeric characters, underscores, and periods are allowed."
+            )
+
+        return identifier
+
     @classmethod
     def _casted_partition_key(cls, key: str) -> str:
         # We need to cast the partition keys to a VARCHAR, since otherwise
         # Athena may throw an error during concatenation / comparison.
-        return f"CAST({key} as VARCHAR)"
+        sanitized_key = cls._sanitize_identifier(key)
+        return f"CAST({sanitized_key} as VARCHAR)"
+
+    @classmethod
+    def _build_max_partition_query(
+        cls, schema: str, table: str, partitions: List[str]
+    ) -> str:
+        """Build SQL query to find the row with maximum partition values.
+
+        Args:
+            schema: Database schema name
+            table: Table name
+            partitions: List of partition column names
+
+        Returns:
+            SQL query string to find the maximum partition
+
+        Raises:
+            ValueError: If any identifier contains unsafe characters
+        """
+        # Sanitize all identifiers to prevent SQL injection
+        sanitized_schema = cls._sanitize_identifier(schema)
+        sanitized_table = cls._sanitize_identifier(table)
+        sanitized_partitions = [
+            cls._sanitize_identifier(partition) for partition in partitions
+        ]
+
+        casted_keys = [cls._casted_partition_key(key) for key in partitions]
+        if len(casted_keys) == 1:
+            part_concat = casted_keys[0]
+        else:
+            separator = "CAST('-' AS VARCHAR)"
+            part_concat = f"CONCAT({f', {separator}, '.join(casted_keys)})"
+
+        return f'select {",".join(sanitized_partitions)} from "{sanitized_schema}"."{sanitized_table}$partitions" where {part_concat} = (select max({part_concat}) from "{sanitized_schema}"."{sanitized_table}$partitions")'
 
     @override
     def get_partitions(
         self, inspector: Inspector, schema: str, table: str
     ) -> Optional[List[str]]:
-        if (
-            not self.config.extract_partitions
-            and not self.config.extract_partitions_using_create_statements
-        ):
+        if not self.config.extract_partitions:
             return None
 
         if not self.cursor:
@@ -557,11 +618,9 @@ class AthenaSource(SQLAlchemySource):
             context=f"{schema}.{table}",
             level=StructuredLogLevel.WARN,
         ):
-            # We create an artifical concatenated partition key to be able to query max partition easier
-            part_concat = " || '-' || ".join(
-                self._casted_partition_key(key) for key in partitions
+            max_partition_query = self._build_max_partition_query(
+                schema, table, partitions
             )
-            max_partition_query = f'select {",".join(partitions)} from "{schema}"."{table}$partitions" where {part_concat} = (select max({part_concat}) from "{schema}"."{table}$partitions")'
             ret = self.cursor.execute(max_partition_query)
             max_partition: Dict[str, str] = {}
             if ret:
@@ -678,16 +737,34 @@ class AthenaSource(SQLAlchemySource):
         ).get(table, None)
 
         if partition and partition.max_partition:
-            max_partition_filters = []
-            for key, value in partition.max_partition.items():
-                max_partition_filters.append(
-                    f"{self._casted_partition_key(key)} = '{value}'"
+            try:
+                # Sanitize identifiers to prevent SQL injection
+                sanitized_schema = self._sanitize_identifier(schema)
+                sanitized_table = self._sanitize_identifier(table)
+
+                max_partition_filters = []
+                for key, value in partition.max_partition.items():
+                    # Sanitize partition key and properly escape the value
+                    sanitized_key = self._sanitize_identifier(key)
+                    # Escape single quotes in the value to prevent injection
+                    escaped_value = value.replace("'", "''") if value else ""
+                    max_partition_filters.append(
+                        f"{self._casted_partition_key(sanitized_key)} = '{escaped_value}'"
+                    )
+                max_partition = str(partition.max_partition)
+                return (
+                    max_partition,
+                    f'SELECT * FROM "{sanitized_schema}"."{sanitized_table}" WHERE {" AND ".join(max_partition_filters)}',
                 )
-            max_partition = str(partition.max_partition)
-            return (
-                max_partition,
-                f'SELECT * FROM "{schema}"."{table}" WHERE {" AND ".join(max_partition_filters)}',
-            )
+            except ValueError as e:
+                # If sanitization fails due to malicious identifiers,
+                # return None to disable partition profiling for this table
+                # rather than crashing the entire ingestion
+                logger.warning(
+                    f"Failed to generate partition profiler query for {schema}.{table} due to unsafe identifiers: {e}. "
+                    f"Partition profiling disabled for this table."
+                )
+                return None, None
         return None, None
 
     def close(self):

datahub/ingestion/source/sql/athena_properties_extractor.py

@@ -174,20 +174,16 @@ class AthenaPropertiesExtractor:
     def format_column_definition(line):
         # Use regex to parse the line more accurately
         # Pattern: column_name data_type [COMMENT comment_text] [,]
-        # Use greedy match for comment to capture everything until trailing comma
-        pattern = r"^\s*(.+?)\s+([\s,\w<>\[\]]+)((\s+COMMENT\s+(.+?)(,?))|(,?)\s*)?$"
-        match = re.match(pattern, line, re.IGNORECASE)
+        # Improved pattern to better separate column name, data type, and comment
+        pattern = r"^\s*([`\w']+)\s+([\w<>\[\](),\s]+?)(\s+COMMENT\s+(.+?))?(,?)\s*$"
+        match = re.match(pattern, line.strip(), re.IGNORECASE)
 
         if not match:
             return line
-        column_name = match.group(1)
-        data_type = match.group(2)
-        comment_part = match.group(5)  # COMMENT part
-        # there are different number of match groups depending on whether comment exists
-        if comment_part:
-            trailing_comma = match.group(6) if match.group(6) else ""
-        else:
-            trailing_comma = match.group(7) if match.group(7) else ""
+        column_name = match.group(1).strip()
+        data_type = match.group(2).strip()
+        comment_part = match.group(4)  # COMMENT part
+        trailing_comma = match.group(5) if match.group(5) else ""
 
         # Add backticks to column name if not already present
         if not (column_name.startswith("`") and column_name.endswith("`")):
@@ -201,17 +197,19 @@ class AthenaPropertiesExtractor:
 
             # Handle comment quoting and escaping
             if comment_part.startswith("'") and comment_part.endswith("'"):
-                # Already properly single quoted - keep as is
-                formatted_comment = comment_part
+                # Already single quoted - but check for proper escaping
+                inner_content = comment_part[1:-1]
+                # Re-escape any single quotes that aren't properly escaped
+                escaped_content = inner_content.replace("'", "''")
+                formatted_comment = f"'{escaped_content}'"
             elif comment_part.startswith('"') and comment_part.endswith('"'):
                 # Double quoted - convert to single quotes and escape internal single quotes
                 inner_content = comment_part[1:-1]
                 escaped_content = inner_content.replace("'", "''")
                 formatted_comment = f"'{escaped_content}'"
             else:
-                # Not quoted - add quotes and escape any single quotes
-                escaped_content = comment_part.replace("'", "''")
-                formatted_comment = f"'{escaped_content}'"
+                # Not quoted - use double quotes to avoid escaping issues with single quotes
+                formatted_comment = f'"{comment_part}"'
 
             result_parts.extend(["COMMENT", formatted_comment])
 
@@ -240,19 +238,39 @@ class AthenaPropertiesExtractor:
                 formatted_lines.append(line)
                 continue
 
-            # Check if we're exiting column definitions (closing parenthesis before PARTITIONED BY or end)
-            if in_column_definition and ")" in line:
-                in_column_definition = False
+            # Skip processing PARTITIONED BY clauses as column definitions
+            if in_column_definition and "PARTITIONED BY" in line.upper():
                 formatted_lines.append(line)
                 continue
 
-            # Process only column definitions (not PARTITIONED BY or other sections)
+            # Process column definitions first, then check for exit condition
             if in_column_definition and stripped_line:
-                # Match column definition pattern and format it
-                formatted_line = AthenaPropertiesExtractor.format_column_definition(
-                    line
-                )
-                formatted_lines.append(formatted_line)
+                # Check if this line contains a column definition (before the closing paren)
+                if ")" in line:
+                    # Split the line at the closing parenthesis
+                    paren_index = line.find(")")
+                    column_part = line[:paren_index].strip()
+                    closing_part = line[paren_index:]
+
+                    if column_part:
+                        # Format the column part
+                        formatted_column = (
+                            AthenaPropertiesExtractor.format_column_definition(
+                                column_part
+                            )
+                        )
+                        # Reconstruct the line
+                        formatted_line = formatted_column.rstrip() + closing_part
+                        formatted_lines.append(formatted_line)
+                    else:
+                        formatted_lines.append(line)
+                    in_column_definition = False
+                else:
+                    # Regular column definition line
+                    formatted_line = AthenaPropertiesExtractor.format_column_definition(
+                        line
+                    )
+                    formatted_lines.append(formatted_line)
             else:
                 # For all other lines, keep as-is
                 formatted_lines.append(line)

datahub/ingestion/source/superset.py

@@ -154,6 +154,7 @@ class SupersetDataset(BaseModel):
     table_name: str
     changed_on_utc: Optional[str] = None
     explore_url: Optional[str] = ""
+    description: Optional[str] = ""
 
     @property
     def modified_dt(self) -> Optional[datetime]:
@@ -1062,7 +1063,7 @@ class SupersetSource(StatefulIngestionSourceBase):
                 fieldPath=col.get("column_name", ""),
                 type=SchemaFieldDataType(data_type),
                 nativeDataType="",
-                description=col.get("column_name", ""),
+                description=col.get("description") or col.get("column_name", ""),
                 nullable=True,
             )
             schema_fields.append(field)
@@ -1283,7 +1284,7 @@ class SupersetSource(StatefulIngestionSourceBase):
 
         dataset_info = DatasetPropertiesClass(
             name=dataset.table_name,
-            description="",
+            description=dataset.description or "",
             externalUrl=dataset_url,
             lastModified=TimeStamp(time=modified_ts),
         )

datahub/ingestion/source/tableau/tableau.py

@@ -1561,12 +1561,15 @@ class TableauSiteSource:
                         }}""",
                     )
             else:
-                # As of Tableau Server 2024.2, the metadata API sporadically returns a 30-second
-                # timeout error.
-                # It doesn't reliably happen, so retrying a couple of times makes sense.
                 if all(
+                    # As of Tableau Server 2024.2, the metadata API sporadically returns a 30-second
+                    # timeout error.
+                    # It doesn't reliably happen, so retrying a couple of times makes sense.
                     error.get("message")
                     == "Execution canceled because timeout of 30000 millis was reached"
+                    # The Metadata API sometimes returns an 'unexpected error' message when querying
+                    # embeddedDatasourcesConnection. Try retrying a couple of times.
+                    or error.get("message") == "Unexpected error occurred"
                     for error in errors
                 ):
                     # If it was only a timeout error, we can retry.
@@ -1578,8 +1581,8 @@ class TableauSiteSource:
                         (self.config.max_retries - retries_remaining + 1) ** 2, 60
                     )
                     logger.info(
-                        f"Query {connection_type} received a 30 second timeout error - will retry in {backoff_time} seconds. "
-                        f"Retries remaining: {retries_remaining}"
+                        f"Query {connection_type} received a retryable error with {retries_remaining} retries remaining, "
+                        f"will retry in {backoff_time} seconds: {errors}"
                     )
                     time.sleep(backoff_time)
                     return self.get_connection_object_page(