soda-redshift 4.0.5__py3-none-any.whl

soda_redshift/common/data_sources/redshift_data_source.py

@@ -0,0 +1,199 @@
+import logging
+from typing import Optional
+
+from soda_core.common.data_source_connection import DataSourceConnection
+from soda_core.common.data_source_impl import DataSourceImpl
+from soda_core.common.logging_constants import soda_logger
+from soda_core.common.metadata_types import DataSourceNamespace, SodaDataTypeName
+from soda_core.common.sql_ast import (
+    COLUMN,
+    CONCAT,
+    CONCAT_WS,
+    COUNT,
+    DISTINCT,
+    FROM,
+    REGEX_LIKE,
+    TUPLE,
+    VALUES,
+)
+from soda_core.common.sql_dialect import SqlDialect
+from soda_core.common.statements.metadata_tables_query import MetadataTablesQuery
+from soda_redshift.common.data_sources.redshift_data_source_connection import (
+    RedshiftDataSource as RedshiftDataSourceModel,
+)
+from soda_redshift.common.data_sources.redshift_data_source_connection import (
+    RedshiftDataSourceConnection,
+)
+from soda_redshift.statements.redshift_metadata_tables_query import (
+    RedshiftMetadataTablesQuery,
+)
+
+logger: logging.Logger = soda_logger
+
+
+REDSHIFT_DOUBLE_PRECISION = "double precision"
+REDSHIFT_CHARACTER_VARYING = "character varying"
+
+
+class RedshiftDataSourceImpl(DataSourceImpl, model_class=RedshiftDataSourceModel):
+    def __init__(self, data_source_model: RedshiftDataSourceModel, connection: Optional[DataSourceConnection] = None):
+        super().__init__(data_source_model=data_source_model, connection=connection)
+
+    def _create_sql_dialect(self) -> SqlDialect:
+        return RedshiftSqlDialect(data_source_impl=self)
+
+    def _create_data_source_connection(self) -> DataSourceConnection:
+        return RedshiftDataSourceConnection(
+            name=self.data_source_model.name, connection_properties=self.data_source_model.connection_properties
+        )
+
+    def create_metadata_tables_query(self) -> MetadataTablesQuery:
+        return RedshiftMetadataTablesQuery(
+            sql_dialect=self.sql_dialect, data_source_connection=self.data_source_connection
+        )
+
+
+class RedshiftSqlDialect(SqlDialect):
+    SODA_DATA_TYPE_SYNONYMS = (
+        (SodaDataTypeName.TEXT, SodaDataTypeName.VARCHAR),
+        (SodaDataTypeName.NUMERIC, SodaDataTypeName.DECIMAL),
+    )
+
+    def get_data_source_data_type_name_by_soda_data_type_names(self) -> dict:
+        return {
+            SodaDataTypeName.CHAR: "char",
+            SodaDataTypeName.VARCHAR: "varchar",
+            SodaDataTypeName.TEXT: "varchar",  # Redshift treats text as varchar(max)
+            SodaDataTypeName.SMALLINT: "smallint",
+            SodaDataTypeName.INTEGER: "integer",
+            SodaDataTypeName.BIGINT: "bigint",
+            SodaDataTypeName.NUMERIC: "numeric",
+            SodaDataTypeName.DECIMAL: "decimal",
+            SodaDataTypeName.FLOAT: "real",  # Redshift float = real (float4)
+            SodaDataTypeName.DOUBLE: REDSHIFT_DOUBLE_PRECISION,  # Redshift uses double precision (float8)
+            SodaDataTypeName.TIMESTAMP: "timestamp",
+            SodaDataTypeName.TIMESTAMP_TZ: "timestamptz",
+            SodaDataTypeName.DATE: "date",
+            SodaDataTypeName.TIME: "time",
+            SodaDataTypeName.BOOLEAN: "boolean",
+        }
+
+    def get_soda_data_type_name_by_data_source_data_type_names(self) -> dict[str, SodaDataTypeName]:
+        return {
+            # Character types
+            "char": SodaDataTypeName.CHAR,
+            "character": SodaDataTypeName.CHAR,
+            "nchar": SodaDataTypeName.CHAR,
+            "varchar": SodaDataTypeName.VARCHAR,
+            REDSHIFT_CHARACTER_VARYING: SodaDataTypeName.VARCHAR,
+            "nvarchar": SodaDataTypeName.VARCHAR,
+            "text": SodaDataTypeName.TEXT,  # synonym, stored as varchar(max)
+            # Integer types
+            "smallint": SodaDataTypeName.SMALLINT,
+            "int2": SodaDataTypeName.SMALLINT,
+            "integer": SodaDataTypeName.INTEGER,
+            "int": SodaDataTypeName.INTEGER,
+            "int4": SodaDataTypeName.INTEGER,
+            "bigint": SodaDataTypeName.BIGINT,
+            "int8": SodaDataTypeName.BIGINT,
+            # Exact numeric types
+            "numeric": SodaDataTypeName.NUMERIC,
+            "decimal": SodaDataTypeName.DECIMAL,
+            # Approximate numeric types
+            "real": SodaDataTypeName.FLOAT,  # float4
+            "float4": SodaDataTypeName.FLOAT,
+            REDSHIFT_DOUBLE_PRECISION: SodaDataTypeName.DOUBLE,  # float8
+            "float8": SodaDataTypeName.DOUBLE,
+            "float": SodaDataTypeName.DOUBLE,  # synonym for float8
+            # Date/time types
+            "timestamp": SodaDataTypeName.TIMESTAMP,
+            "timestamp without time zone": SodaDataTypeName.TIMESTAMP,
+            "timestamptz": SodaDataTypeName.TIMESTAMP_TZ,
+            "timestamp with time zone": SodaDataTypeName.TIMESTAMP_TZ,
+            "date": SodaDataTypeName.DATE,
+            "time": SodaDataTypeName.TIME,
+            "time without time zone": SodaDataTypeName.TIME,
+            # Boolean type
+            "boolean": SodaDataTypeName.BOOLEAN,
+            "bool": SodaDataTypeName.BOOLEAN,
+        }
+
+    def _get_data_type_name_synonyms(self) -> list[list[str]]:
+        return [
+            ["varchar", REDSHIFT_CHARACTER_VARYING],
+            ["char", "character"],
+            ["smallint", "int2"],
+            ["integer", "int", "int4"],
+            ["bigint", "int8"],
+            ["real", "float4", "float"],
+            [REDSHIFT_DOUBLE_PRECISION, "float8"],
+            ["timestamp", "timestamp without time zone"],
+            ["time", "time without time zone"],
+        ]
+
+    def _build_regex_like_sql(self, matches: REGEX_LIKE) -> str:
+        expression: str = self.build_expression_sql(matches.expression)
+        return f"{expression} ~ '{matches.regex_pattern}'"
+
+    def _build_tuple_sql(self, tuple: TUPLE) -> str:
+        if tuple.check_context(COUNT) and tuple.check_context(DISTINCT):
+            return self._build_tuple_sql_in_distinct(tuple)
+        if tuple.check_context(VALUES):
+            return f"{','.join(self.build_expression_sql(e) for e in tuple.expressions)}"
+        return f"{super()._build_tuple_sql(tuple)}"
+
+    def _build_tuple_sql_in_distinct(self, tuple: TUPLE) -> str:
+        """
+        Redshift does not support DISTINCT on tuples and has nothing like BigQuery's TO_JSON_STRING(STRUCT).
+
+        Instead we approximate TO_JSON_STRING(STRUCT) by concatting all the columns.
+        """
+
+        def format_element_expression(e: str) -> str:
+            """Use CHR(31) (unit seperator) as delimiter because it is highly unlikely to be appear in the data.
+            If it does appear, replace with string '#US#'.  Also replace NULL with a string value to prevent
+            cascading NULLS in the concat operation."""
+            return f"REPLACE(COALESCE(CAST({e} AS VARCHAR), '__UNDEF__'), CHR(31), '#US#')"
+
+        concat_delim = " || CHR(31) || \n"  # use ASCII unit separator as delimieter
+        elements: str = concat_delim.join(
+            format_element_expression(self.build_expression_sql(e)) for e in tuple.expressions
+        )
+        # Use FNV_HASH to convert the string rep into a hash value with a fixed length, will be more performant in COUNT DISTINCT
+        return f"FNV_HASH({elements})"
+
+    def build_cte_values_sql(self, values: VALUES, alias_columns: list[COLUMN] | None) -> str:
+        return "\nUNION ALL\n".join(["SELECT " + self.build_expression_sql(value) for value in values.values])
+
+    def data_type_has_parameter_character_maximum_length(self, data_type_name) -> bool:
+        return data_type_name.lower() in ["varchar", "char", REDSHIFT_CHARACTER_VARYING, "character"]
+
+    def data_type_has_parameter_numeric_precision(self, data_type_name) -> bool:
+        return data_type_name.lower() in ["numeric", "number", "decimal"]
+
+    def data_type_has_parameter_numeric_scale(self, data_type_name) -> bool:
+        return data_type_name.lower() in ["numeric", "number", "decimal"]
+
+    def data_type_has_parameter_datetime_precision(self, data_type_name) -> bool:
+        return False
+
+    def supports_data_type_datetime_precision(self) -> bool:
+        return False
+
+    def _build_concat_ws_sql(self, concat_ws: CONCAT_WS) -> str:
+        return f" || '{concat_ws.separator}' || ".join(self.build_expression_sql(e) for e in concat_ws.expressions)
+
+    def _build_concat_sql(self, concat: CONCAT) -> str:
+        return f" || ".join(self.build_expression_sql(e) for e in concat.expressions)
+
+    def supports_materialized_views(self) -> bool:
+        return True
+
+    def table_columns(self) -> str:
+        return self.default_casify("svv_columns")
+
+    def build_columns_metadata_from_clause(self, table_namespace: DataSourceNamespace) -> FROM:
+        return FROM(self.table_columns()).IN(self._pg_catalog_schema())
+
+    def _pg_catalog_schema(self) -> str:
+        return "pg_catalog"

soda_redshift/common/data_sources/redshift_data_source_connection.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from abc import ABC
+from ipaddress import IPv4Address, IPv6Address
+from typing import Literal, Optional, Union
+
+import boto3
+import psycopg2
+from pydantic import Field, IPvAnyAddress, SecretStr
+from soda_core.common.aws_credentials import AwsCredentials
+from soda_core.common.data_source_connection import DataSourceConnection
+from soda_core.model.data_source.data_source import DataSourceBase
+from soda_core.model.data_source.data_source_connection_properties import (
+    DataSourceConnectionProperties,
+)
+
+
+class RedshiftConnectionProperties(DataSourceConnectionProperties):
+    user: str = Field(..., description="Database username")
+    host: Union[str, IPvAnyAddress] = Field(..., description="Database host (hostname or IP address)")
+    port: Optional[int] = Field(5439, description="Database port (1-65535)", ge=1, le=65535)
+    database: str = Field(..., description="Database name", min_length=1, max_length=63)
+    connect_timeout: Optional[int] = Field(None, description="Connection timeout")
+    keepalives_idle: Optional[int] = Field(None, description="Keepalives idle")
+    keepalives_interval: Optional[int] = Field(None, description="Keepalives interval")
+    keepalives_count: Optional[int] = Field(None, description="Keepalives count")
+
+
+class RedshiftUserPassConnection(RedshiftConnectionProperties):
+    password: SecretStr = Field(..., description="Database password")
+
+
+class RedshiftKeyConnection(RedshiftConnectionProperties):
+    access_key_id: str = Field(..., description="AWS access key ID")
+    secret_access_key: SecretStr = Field(..., description="AWS secret access key")
+    session_token: Optional[str] = Field(None, description="AWS session token")
+    role_arn: Optional[str] = Field(None, description="AWS role ARN")
+    region: Optional[str] = Field("eu-west-1", description="AWS region")
+    profile_name: Optional[str] = Field(None, description="AWS profile name")
+    cluster_identifier: Optional[str] = Field(None, description="Redshift cluster identifier")
+
+
+class RedshiftDataSource(DataSourceBase, ABC):
+    type: Literal["redshift"] = Field("redshift")
+
+    connection_properties: Union[
+        RedshiftUserPassConnection,
+        RedshiftKeyConnection,
+    ] = Field(..., alias="connection", description="Redshift connection configuration")
+
+
+class RedshiftDataSourceConnection(DataSourceConnection):
+    def __init__(self, name: str, connection_properties: DataSourceConnectionProperties):
+        super().__init__(name, connection_properties)
+
+    def _extract_cluster_identifier(self):
+        if isinstance(self.host, (IPv4Address, IPv6Address)):
+            raise ValueError("Cluster identifier is required when using an IP address as host")
+        # strip protocol if present
+        host = self.host.split("://")[1] if "://" in self.host else self.host
+        return host.split(".")[0]
+
+    def _get_cluster_credentials(self, aws_credentials: AwsCredentials, cluster_identifier: Optional[str] = None):
+        resolved_aws_credentials = aws_credentials.resolve_role(
+            role_session_name="soda_redshift_get_cluster_credentials"
+        )
+
+        client = boto3.client(
+            "redshift",
+            region_name=resolved_aws_credentials.region_name,
+            aws_access_key_id=resolved_aws_credentials.access_key_id,
+            aws_secret_access_key=resolved_aws_credentials.secret_access_key,
+            aws_session_token=resolved_aws_credentials.session_token,
+        )
+
+        cluster_identifier = self._extract_cluster_identifier() if not cluster_identifier else cluster_identifier
+
+        user = self.user
+        db_name = self.database
+        # Note  user is used here to get database credentials, therefore it's required even if AWS creds are provided
+        cluster_creds = client.get_cluster_credentials(
+            DbUser=user, DbName=db_name, ClusterIdentifier=cluster_identifier, AutoCreate=False, DurationSeconds=3600
+        )
+
+        return cluster_creds["DbUser"], cluster_creds["DbPassword"]
+
+    def _load_params(self, config: RedshiftConnectionProperties):
+        self.user = config.user
+        self.host = config.host
+        self.port = config.port
+        self.database = config.database
+        self.connect_timeout = config.connect_timeout
+
+        self.keepalives_params = {}
+        if config.keepalives_idle:
+            self.keepalives_params["keepalives_idle"] = config.keepalives_idle
+        if config.keepalives_interval:
+            self.keepalives_params["keepalives_interval"] = config.keepalives_interval
+        if config.keepalives_count:
+            self.keepalives_params["keepalives_count"] = config.keepalives_count
+
+    def _create_connection(
+        self,
+        config: RedshiftConnectionProperties,
+    ):
+        self._load_params(config)
+
+        if isinstance(config, RedshiftUserPassConnection):
+            self.password = config.password.get_secret_value()
+        elif isinstance(config, RedshiftKeyConnection):
+            aws_credentials = AwsCredentials(
+                access_key_id=config.access_key_id,
+                secret_access_key=config.secret_access_key.get_secret_value(),
+                role_arn=config.role_arn,
+                session_token=config.session_token,
+                region_name=config.region,
+                profile_name=config.profile_name,
+            )
+            self.user, self.password = self._get_cluster_credentials(aws_credentials, config.cluster_identifier)
+
+        # Redshift is case-insensitive by default unless explicitly enabled.
+        # It's possible customers may have enabled case-sensitivity in their databases, therefore we enable that in
+        # to support databases configured that way.
+        options = "-c enable_case_sensitive_identifier=on"
+
+        conn = psycopg2.connect(
+            user=self.user,
+            password=self.password,
+            host=self.host,
+            port=self.port,
+            connect_timeout=self.connect_timeout,
+            database=self.database,
+            options=options,
+            **self.keepalives_params,
+        )
+        conn.autocommit = True
+        return conn

soda_redshift/statements/redshift_metadata_tables_query.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from soda_core.common.data_source_results import QueryResult
+from soda_core.common.logging_constants import soda_logger
+from soda_core.common.sql_ast import (
+    COLUMN,
+    EQ,
+    FROM,
+    LIKE,
+    LITERAL,
+    LOWER,
+    NOT_LIKE,
+    OR,
+    RAW_SQL,
+    SELECT,
+    UNION_ALL,
+    WHERE,
+)
+from soda_core.common.statements.metadata_tables_query import MetadataTablesQuery
+from soda_core.common.statements.table_types import (
+    FullyQualifiedMaterializedViewName,
+    FullyQualifiedObjectName,
+    FullyQualifiedViewName,
+    TableType,
+)
+
+logger: logging.Logger = soda_logger
+
+
+class RedshiftMetadataTablesQuery(MetadataTablesQuery):
+    def execute(
+        self,
+        database_name: Optional[str] = None,
+        schema_name: Optional[str] = None,
+        include_table_name_like_filters: Optional[list[str]] = None,
+        exclude_table_name_like_filters: Optional[list[str]] = None,
+        types_to_return: Optional[
+            list[TableType]
+        ] = None,  # To make sure it's backwards compatible with the old behavior, when we use None it should default to [TableType.TABLE]
+    ) -> list[FullyQualifiedObjectName]:
+        if types_to_return is None:
+            types_to_return = [TableType.TABLE]
+        select_statement: UNION_ALL = self.build_sql_statement(
+            database_name=database_name,
+            schema_name=schema_name,
+            include_table_name_like_filters=include_table_name_like_filters,
+            exclude_table_name_like_filters=exclude_table_name_like_filters,
+        )
+        sql: str = self.sql_dialect.build_union_sql(select_statement)
+        query_result: QueryResult = self.data_source_connection.execute_query(sql)
+        return self.get_results(query_result, types_to_return)
+
+    def build_sql_statement(
+        self,
+        database_name: Optional[str] = None,
+        schema_name: Optional[str] = None,
+        include_table_name_like_filters: Optional[list[str]] = None,
+        exclude_table_name_like_filters: Optional[list[str]] = None,
+    ) -> UNION_ALL:
+        """
+        Builds the full SQL query statement to query table names from the data source metadata.
+
+        Redshift specific implementation that queries both regular tables and materialized views.
+        svv_tables does include materialized views, but does not indicate them as such, only as 'VIEW' in the table_type column.
+        Therefore, we need to query svv_mv_info separately to get the materialized views to be consistent with other datasources that support materialized views.
+        """
+        table_select = [
+            SELECT(
+                [
+                    COLUMN("table_catalog"),
+                    COLUMN("table_schema"),
+                    COLUMN("table_name"),
+                    COLUMN("table_type"),
+                ]
+            ),
+            FROM("svv_tables"),
+        ]
+        matview_select = [
+            SELECT(
+                [
+                    COLUMN("database_name", field_alias="table_catalog"),
+                    COLUMN("schema_name", field_alias="table_schema"),
+                    COLUMN("name", field_alias="table_name"),
+                    RAW_SQL("'MATERIALIZED VIEW' AS TABLE_TYPE"),
+                ]
+            ),
+            FROM("svv_mv_info"),
+        ]
+
+        statement = UNION_ALL([table_select, matview_select])
+
+        if database_name:
+            database_name_lower: str = database_name.lower()
+            table_select.append(WHERE(EQ(LOWER("table_catalog"), LITERAL(database_name_lower))))
+            matview_select.append(WHERE(EQ(LOWER("database_name"), LITERAL(database_name_lower))))
+
+        if schema_name:
+            table_select.append(WHERE(EQ(LOWER("table_schema"), LITERAL(schema_name.lower()))))
+            matview_select.append(WHERE(EQ(LOWER("schema_name"), LITERAL(schema_name.lower()))))
+
+        if include_table_name_like_filters:
+            table_select.append(
+                WHERE(
+                    OR(
+                        [
+                            LIKE(LOWER(COLUMN("table_name")), LITERAL(include_table_name_like_filter.lower()))
+                            for include_table_name_like_filter in include_table_name_like_filters
+                        ]
+                    )
+                )
+            )
+            matview_select.append(
+                WHERE(
+                    OR(
+                        [
+                            LIKE(LOWER(COLUMN("name")), LITERAL(include_table_name_like_filter.lower()))
+                            for include_table_name_like_filter in include_table_name_like_filters
+                        ]
+                    )
+                )
+            )
+
+        if exclude_table_name_like_filters:
+            for exclude_table_name_like_filter in exclude_table_name_like_filters:
+                table_select.append(
+                    WHERE(NOT_LIKE(LOWER(COLUMN("table_name")), LITERAL(exclude_table_name_like_filter.lower())))
+                )
+                matview_select.append(
+                    WHERE(NOT_LIKE(LOWER(COLUMN("name")), LITERAL(exclude_table_name_like_filter.lower())))
+                )
+
+        return statement
+
+    def get_results(
+        self, query_result: QueryResult, types_to_return: list[TableType]
+    ) -> list[FullyQualifiedObjectName]:
+        result = super().get_results(query_result, types_to_return)
+        filtered = []
+        # Redshift represents materialized views as 'VIEW' in the table_type column in svv_tables,
+        # so we need to remove them from the result if corresponding materialized view is present.
+        # Populate the filtered list with materialized views first, then add the rest if not already present.
+        materialized_view_names = {
+            (obj.database_name, obj.schema_name, obj.get_object_name())
+            for obj in result
+            if isinstance(obj, FullyQualifiedMaterializedViewName)
+        }
+        for obj in result:
+            if isinstance(obj, FullyQualifiedMaterializedViewName):
+                filtered.append(obj)
+            elif isinstance(obj, FullyQualifiedViewName):
+                if (obj.database_name, obj.schema_name, obj.get_object_name()) not in materialized_view_names:
+                    filtered.append(obj)
+                else:
+                    logger.debug(
+                        f"Excluding view {obj.get_object_name()} in schema {obj.schema_name} from results as a materialized view with the same name exists."
+                    )
+            else:
+                filtered.append(obj)
+        return filtered

soda_redshift/test_helpers/redshift_data_source_test_helper.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import os
+
+REDSHIFT_HOST = os.getenv("REDSHIFT_HOST", "")
+REDSHIFT_PORT = os.getenv("REDSHIFT_PORT", None)
+REDSHIFT_DATABASE = os.getenv("REDSHIFT_DATABASE", "soda_test")
+REDSHIFT_USERNAME = os.getenv("REDSHIFT_USERNAME", "")
+REDSHIFT_PASSWORD = os.getenv("REDSHIFT_PASSWORD", "")
+
+from helpers.data_source_test_helper import DataSourceTestHelper
+
+
+class RedshiftDataSourceTestHelper(DataSourceTestHelper):
+    def _create_database_name(self) -> str | None:
+        return os.getenv("REDSHIFT_DATABASE", "soda_test")
+
+    def _create_data_source_yaml_str(self) -> str:
+        """
+        Called in _create_data_source_impl to initialized self.data_source_impl
+        self.database_name and self.schema_name are available if appropriate for the data source type
+        """
+        return f"""
+            type: redshift
+            name: {self.name}
+            connection:
+                host: '{REDSHIFT_HOST}'
+                port: {REDSHIFT_PORT}
+                database: '{REDSHIFT_DATABASE}'
+                user: '{REDSHIFT_USERNAME}'
+                password: '{REDSHIFT_PASSWORD}'
+        """

soda_redshift-4.0.5.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: soda-redshift
+Version: 4.0.5
+Requires-Dist: soda-core==4.0.5
+Requires-Dist: psycopg2-binary<3.0,>=2.8.5
+Requires-Dist: boto3
+Dynamic: requires-dist

soda_redshift-4.0.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+soda_redshift/common/data_sources/redshift_data_source.py,sha256=3759lHK33qLSXDuVmaJyhYssiPFC2Kr1y4zOeTCgxMM,8792
+soda_redshift/common/data_sources/redshift_data_source_connection.py,sha256=SSn6ymYcmCOjhOFVfcECn1OqQh3y_dxY4mbJGvAIx-U,6155
+soda_redshift/statements/redshift_metadata_tables_query.py,sha256=kiEL7zN6Glc8Uw3AqRsvgzikwj9KW6posOkBV7Dg1qU,6646
+soda_redshift/test_helpers/redshift_data_source_test_helper.py,sha256=voNNQwI0q2SyQVVUANvzCIDpFiNwAb_FanwQwzadjb4,1142
+soda_redshift-4.0.5.dist-info/METADATA,sha256=7tgFpJqiIVjPKIIh8d50Vm8gggL-fUOgZLcHdJVbRAc,176
+soda_redshift-4.0.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+soda_redshift-4.0.5.dist-info/entry_points.txt,sha256=vCD53lIm78uSTfxwYSgO-_4Y-7B2JwLUjRyYut3hy6o,139
+soda_redshift-4.0.5.dist-info/top_level.txt,sha256=Ig6iDH2X2DjhgCaIIVhDXwu6_V9fI8CPYNsUWAKb6aw,14
+soda_redshift-4.0.5.dist-info/RECORD,,

soda_redshift-4.0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

soda_redshift-4.0.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[soda.plugins.data_source.redshift]
+RedshiftDataSourceImpl = soda_redshift.common.data_sources.redshift_data_source:RedshiftDataSourceImpl

soda_redshift-4.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+soda_redshift