dbt-maxcompute 1.8.0a0__py3-none-any.whl

dbt/adapters/maxcompute/__init__.py

@@ -0,0 +1,13 @@
+from dbt.adapters.maxcompute.connections import MaxComputeConnectionManager # noqa
+from dbt.adapters.maxcompute.connections import MaxComputeCredentials
+from dbt.adapters.maxcompute.impl import MaxComputeAdapter
+
+from dbt.adapters.base import AdapterPlugin
+from dbt.include import maxcompute
+
+
+Plugin = AdapterPlugin(
+    adapter=MaxComputeAdapter,
+    credentials=MaxComputeCredentials,
+    include_path=maxcompute.PACKAGE_PATH
+    )

dbt/adapters/maxcompute/__version__.py

@@ -0,0 +1 @@
+version = "1.8.0-alpha"

dbt/adapters/maxcompute/column.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+from typing import TypeVar, Any
+
+from dbt.adapters.base.column import Column
+from odps.models.table import TableSchema
+from odps.types import Decimal, Varchar
+
+_PARENT_DATA_TYPE_KEY = "__parent_data_type"
+
+Self = TypeVar("Self", bound="MaxComputeColumn")
+
+
+@dataclass
+class MaxComputeColumn(Column):
+    table_column: TableSchema.TableColumn = None
+    comment: str = None
+
+    TYPE_LABELS = {
+        "TEXT": "STRING",
+    }
+
+    @property
+    def quoted(self):
+        return "`{}`".format(self.column)
+
+    def literal(self, value):
+        return "cast({} as {})".format(value, self.dtype)
+
+    @property
+    def data_type(self) -> str:
+        return self.dtype
+
+    @classmethod
+    def numeric_type(cls, dtype: str, precision: Any, scale: Any) -> str:
+        # MaxCompute makes life much harder if precision + scale are specified
+        # even if they're fed in here, just return the data type by itself
+        return dtype
+
+    def is_string(self) -> bool:
+        return self.dtype.lower() == "string"
+
+    def can_expand_to(self: Self, other_column: Self) -> bool:  # type: ignore
+        """returns True if both columns are strings"""
+        return self.is_string() and other_column.is_string()
+
+    def __repr__(self) -> str:
+        return "<MaxComputeColumn {} ({})>".format(self.name, self.data_type)
+
+    @classmethod
+    def from_odps_column(cls, column: TableSchema.TableColumn):
+        char_size = None
+        numeric_precision = None
+        numeric_scale = None
+
+        if isinstance(column.type, Decimal):
+            numeric_precision = column.type.precision
+            numeric_scale = column.type.scale
+        elif isinstance(column.type, Varchar):
+            char_size = column.type.size_limit
+
+        return cls(
+            column=column.name,
+            dtype=column.type.name,
+            char_size=char_size,
+            numeric_precision=numeric_precision,
+            numeric_scale=numeric_scale,
+            table_column=column,
+            comment=column.comment,
+        )

dbt/adapters/maxcompute/connections.py

@@ -0,0 +1,109 @@
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Dict, Any
+
+from dbt_common.exceptions import (
+    DbtConfigError,
+    DbtRuntimeError
+)
+from dbt.adapters.contracts.connection import Credentials, AdapterResponse
+
+from dbt.adapters.sql import SQLConnectionManager
+from dbt.adapters.events.logging import AdapterLogger
+
+from odps import ODPS
+import odps.dbapi
+
+from dbt.adapters.maxcompute.context import set_dbt_default_schema
+from dbt.adapters.maxcompute.wrapper import ConnectionWrapper
+
+logger = AdapterLogger("MaxCompute")
+
+@dataclass
+class MaxComputeCredentials(Credentials):
+    endpoint: str
+    accessId: str
+    accessKey: str
+
+    _ALIASES = {
+        'project': 'database',
+        'ak': 'accessId',
+        'sk': 'accessKey',
+    }
+
+    @property
+    def type(self):
+        return "maxcompute"
+
+    @property
+    def unique_field(self):
+        return self.endpoint + '_' + self.database
+
+    def _connection_keys(self):
+        return ("project", "database")
+
+
+class MaxComputeConnectionManager(SQLConnectionManager):
+    TYPE = "maxcompute"
+
+    @classmethod
+    def open(cls, connection):
+        if connection.state == 'open':
+            logger.debug('Connection is already open, skipping open.')
+            return connection
+
+        credentials = connection.credentials
+
+        o = ODPS(
+            credentials.accessId,
+            credentials.accessKey,
+            project=credentials.database,
+            endpoint=credentials.endpoint,
+        )
+        o.schema = credentials.schema
+        set_dbt_default_schema(credentials.schema)
+
+        try:
+            o.get_project().reload()
+        except Exception as e:
+            raise DbtConfigError(f"Failed to connect to MaxCompute: {str(e)}") from e
+
+        handle = ConnectionWrapper(odps=o, hints={'odps.sql.submit.mode': 'script', 'odps.sql.allow.cartesian':'true'})
+        connection.state = 'open'
+        connection.handle = handle
+        return connection
+
+    @classmethod
+    def get_response(cls, cursor):
+        # FIXME：we should get 'code', 'message', 'rows_affected' from cursor
+        logger.info("Current instance id is " + cursor._instance.id)
+        return AdapterResponse(_message="OK")
+
+    def set_query_header(self, query_header_context: Dict[str, Any]) -> None:
+        # no query header will better
+        pass
+
+    @contextmanager
+    def exception_handler(self, sql: str):
+        try:
+            yield
+        except Exception as exc:
+            logger.debug("Error while running:\n{}".format(sql))
+            logger.debug(exc)
+            if len(exc.args) == 0:
+                raise
+            thrift_resp = exc.args[0]
+            if hasattr(thrift_resp, "status"):
+                msg = thrift_resp.status.errorMessage
+                raise DbtRuntimeError(msg)
+            else:
+                raise DbtRuntimeError(str(exc))
+
+    def cancel(self, connection):
+        connection.handle.cancel()
+
+    def add_begin_query(self):
+        pass
+
+    def add_commit_query(self):
+        pass

dbt/adapters/maxcompute/context.py

@@ -0,0 +1,17 @@
+import threading
+
+DBT_DEFAULT_SCHEMA = "__dbt_default__"
+
+schema_lock = threading.Lock()
+
+
+def set_dbt_default_schema(schema):
+    global DBT_DEFAULT_SCHEMA
+    with schema_lock:
+        DBT_DEFAULT_SCHEMA = schema
+
+
+def get_dbt_default_schema():
+    global DBT_DEFAULT_SCHEMA
+    with schema_lock:
+        return DBT_DEFAULT_SCHEMA

dbt/adapters/maxcompute/impl.py

@@ -0,0 +1,259 @@
+import time
+from dataclasses import dataclass
+from functools import lru_cache
+from multiprocessing.context import SpawnContext
+from typing import Optional, List, Dict, Any
+
+import agate
+from dbt.adapters.base import ConstraintSupport
+from dbt.adapters.capability import CapabilityDict, Capability, CapabilitySupport, Support
+from dbt.adapters.contracts.macros import MacroResolverProtocol
+from dbt.adapters.contracts.relation import RelationType
+from dbt.adapters.protocol import AdapterConfig
+from dbt.adapters.sql import SQLAdapter
+from dbt_common.contracts.constraints import ConstraintType
+from dbt_common.utils import AttrDict
+from odps.errors import ODPSError, NoSuchObject
+
+from dbt.adapters.maxcompute import MaxComputeConnectionManager
+from dbt.adapters.maxcompute.column import MaxComputeColumn
+from dbt.adapters.maxcompute.relation import MaxComputeRelation
+from dbt.adapters.events.logging import AdapterLogger
+
+from dbt.adapters.maxcompute.utils import retry_on_exception
+
+logger = AdapterLogger("MaxCompute")
+
+
+@dataclass
+class MaxComputeConfig(AdapterConfig):
+    partitionColumns: Optional[List[Dict[str, str]]] = None
+    sqlHints: Optional[Dict[str, str]] = None
+
+
+class MaxComputeAdapter(SQLAdapter):
+    RELATION_TYPES = {
+        "TABLE": RelationType.Table,
+        "VIEW": RelationType.View,
+        "MATERIALIZED_VIEW": RelationType.MaterializedView,
+        "EXTERNAL": RelationType.External,
+    }
+
+    ConnectionManager = MaxComputeConnectionManager
+    Relation = MaxComputeRelation
+    Column = MaxComputeColumn
+    AdapterSpecificConfigs = MaxComputeConfig
+
+    CONSTRAINT_SUPPORT = {
+        ConstraintType.check: ConstraintSupport.NOT_SUPPORTED,
+        ConstraintType.not_null: ConstraintSupport.ENFORCED,
+        ConstraintType.unique: ConstraintSupport.NOT_ENFORCED,
+        ConstraintType.primary_key: ConstraintSupport.NOT_ENFORCED,
+        ConstraintType.foreign_key: ConstraintSupport.NOT_SUPPORTED,
+    }
+
+    _capabilities: CapabilityDict = CapabilityDict(
+        {
+            Capability.TableLastModifiedMetadata: CapabilitySupport(support=Support.Full),
+            Capability.SchemaMetadataByRelations: CapabilitySupport(support=Support.Full),
+        }
+    )
+
+    def __init__(self, config, mp_context: SpawnContext) -> None:
+        super().__init__(config, mp_context)
+        self.connections: MaxComputeConnectionManager = self.connections
+
+    def get_odps_client(self):
+        conn = self.connections.get_thread_connection()
+        return conn.handle.odps
+
+    def get_odps_table_by_relation(self, relation: MaxComputeRelation):
+        if self.get_odps_client().exist_table(relation.identifier, relation.project, relation.schema):
+            return self.get_odps_client().get_table(relation.identifier, relation.project, relation.schema)
+        return None
+
+    @lru_cache(maxsize=100)  # Cache results with no limit on size
+    def support_namespace_schema(self, project: str):
+        return self.get_odps_client().get_project(project).get_property("odps.schema.model.enabled",
+                                                                        "false") == "true"
+
+    ###
+    # Implementations of abstract methods
+    ###
+    @classmethod
+    def date_function(cls) -> str:
+        return "current_timestamp()"
+
+    @classmethod
+    def is_cancelable(cls) -> bool:
+        return True
+
+    def drop_relation(self, relation: MaxComputeRelation) -> None:
+        is_cached = self._schema_is_cached(relation.database, relation.schema)
+        if is_cached:
+            self.cache_dropped(relation)
+        conn = self.connections.get_thread_connection()
+        conn.handle.odps.delete_table(relation.identifier, relation.project, True, relation.schema)
+
+    def truncate_relation(self, relation: MaxComputeRelation) -> None:
+        # use macro to truncate
+        sql = super().truncate_relation(relation)
+        logger.info(f"execute sql: {sql}")
+        self.get_odps_client().execute_sql(sql)
+
+    def rename_relation(
+            self, from_relation: MaxComputeRelation, to_relation: MaxComputeRelation
+    ) -> None:
+        # use macro to rename
+        super().rename_relation(from_relation, to_relation)
+
+    def get_columns_in_relation(self, relation: MaxComputeRelation):
+        logger.info(f"get_columns_in_relation: {relation.render()}")
+        odps_table = self.get_odps_table_by_relation(relation)
+        return (
+            [MaxComputeColumn.from_odps_column(column) for column in odps_table.table_schema.simple_columns]
+            if odps_table
+            else []
+        )
+
+    def execute_macro(
+            self,
+            macro_name: str,
+            macro_resolver: Optional[MacroResolverProtocol] = None,
+            project: Optional[str] = None,
+            context_override: Optional[Dict[str, Any]] = None,
+            kwargs: Optional[Dict[str, Any]] = None,
+            needs_conn: bool = False,
+    ) -> AttrDict:
+        sql = super().execute_macro(
+            macro_name,
+            macro_resolver=macro_resolver,
+            project=project,
+            context_override=context_override,
+            kwargs=kwargs,
+            needs_conn=needs_conn
+        )
+        inst = self.get_odps_client().run_sql(sql=sql)
+        logger.info(f"create instance id '{inst.id}', execute_sql: '{sql}'")
+        inst.wait_for_success()
+        return sql
+
+
+
+    def create_schema(self, relation: MaxComputeRelation) -> None:
+        logger.info(f"create_schema: '{relation.project}.{relation.schema}'")
+
+        # Although the odps client has a check schema exist method, it will have a considerable delay,
+        # so that it is impossible to judge how many seconds it should wait.
+        # The same purpose is achieved by directly deleting and capturing the schema does not exist exception.
+
+        try:
+            self.get_odps_client().create_schema(relation.schema, relation.database)
+        except ODPSError as e:
+            if e.code == "ODPS-0110061":
+                return
+            else:
+                raise e
+        # self.checkSchemaDeeply(relation.schema, relation.database, True)
+
+    def drop_schema(self, relation: MaxComputeRelation) -> None:
+        logger.info(f"drop_schema: '{relation.project}.{relation.schema}'")
+
+        # Although the odps client has a check schema exist method, it will have a considerable delay,
+        # so that it is impossible to judge how many seconds it should wait.
+        # The same purpose is achieved by directly deleting and capturing the schema does not exist exception.
+
+        try:
+            self.get_odps_client().delete_schema(relation.schema, relation.database)
+        except ODPSError as e:
+            if e.code == "ODPS-0110061":
+                return
+            else:
+                raise e
+        # self.checkSchemaDeeply(relation.schema, relation.database, False)
+
+    def checkSchemaDeeply(self, schema, project, expect_exist):
+        logger.info(f"checkSchemaDeeply: {project}.{schema}, expect schema exist: {expect_exist}")
+        for retry in range(0, 5):
+            try:
+                self.get_odps_client().execute_sql(
+                    f"create or replace view {project}.{schema}.__check_schema_exist__ as select 1;")
+                if not expect_exist:
+                    return
+                logger.info(f"{project}.{schema} still exist, continue to wait.")
+                self.get_odps_client().execute_sql(
+                    f"drop view {project}.{schema}.__check_schema_exist__;")
+            except ODPSError as e:
+                if e.code == "ODPS-0110061":
+                    if expect_exist:
+                        return
+                    logger.info(f"{project}.{schema} not exist, continue to wait.")
+                else:
+                    raise e
+            time.sleep(5)
+
+    def list_relations_without_caching(
+            self,
+            schema_relation: MaxComputeRelation,
+    ) -> List[MaxComputeRelation]:
+        logger.info(f"list_relations_without_caching: {schema_relation}")
+        if not self.check_schema_exists(schema_relation.database, schema_relation.schema):
+            return []
+        results = self.get_odps_client().list_tables(project=schema_relation.database,
+                                                     schema=schema_relation.schema)
+        relations = []
+        for table in results:
+            relations.append(
+                MaxComputeRelation.from_odps_table(table)
+            )
+        return relations
+
+    @classmethod
+    def quote(cls, identifier):
+        return '`{}`'.format(identifier)
+
+    def list_schemas(self, database: str) -> List[str]:
+        database = database.split('.')[0]
+        database = database.strip('`')
+        if not self.support_namespace_schema(database):
+            return ["default"]
+        res = [schema.name for schema in self.get_odps_client().list_schemas(database)]
+
+        logger.info(f"list_schemas: {res}")
+        return res
+
+    def check_schema_exists(self, database: str, schema: str) -> bool:
+        database = database.strip('`')
+        if not self.support_namespace_schema(database):
+            return False
+        schema = schema.strip('`')
+        time.sleep(10)
+        schema_exist = self.get_odps_client().exist_schema(schema, database)
+        logger.info(f"check_schema_exists: {database}.{schema}, answer is {schema_exist}")
+        return schema_exist
+
+    # MaxCompute does not support transactions
+    def clear_transaction(self) -> None:
+        pass
+
+    @classmethod
+    def convert_text_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
+        return "string"
+
+    @classmethod
+    def convert_number_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
+        return "decimal"
+
+    @classmethod
+    def convert_integer_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
+        return "bigint"
+
+    @classmethod
+    def convert_datetime_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
+        return "timestamp_ntz"
+
+    @classmethod
+    def convert_time_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
+        return "timestamp_ntz"
+
+    # TODO: standardize_grants_dict method may also be overridden

dbt/adapters/maxcompute/relation.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass, field
+from typing import FrozenSet, Optional, TypeVar, Type
+
+from dbt.adapters.base.relation import BaseRelation, ComponentName, InformationSchema
+from dbt.adapters.contracts.relation import RelationType, Path, Policy
+from dbt_common.utils.dict import filter_null_values
+from odps.models import Table
+
+from dbt.adapters.maxcompute.context import get_dbt_default_schema
+
+Self = TypeVar("Self", bound="MaxComputeRelation")
+
+
+@dataclass
+class OdpsIncludePolicy(Policy):
+    database: bool = True
+    schema: bool = True
+    identifier: bool = True
+
+
+@dataclass(frozen=True, eq=False, repr=False)
+class MaxComputeRelation(BaseRelation):
+    quote_character: str = "`"
+    # subquery alias name is not required in MaxCompute
+    require_alias: bool = False
+
+    def without_quote(self):
+        return self.quote(False, False, False)
+
+    include_policy: Policy = field(default_factory=lambda: OdpsIncludePolicy())
+
+
+    renameable_relations: FrozenSet[RelationType] = field(
+        default_factory=lambda: frozenset(
+            {
+                RelationType.View,
+                RelationType.Table,
+            }
+        )
+    )
+
+    replaceable_relations: FrozenSet[RelationType] = field(
+        default_factory=lambda: frozenset(
+            {
+                RelationType.View,
+                RelationType.Table,
+            }
+        )
+    )
+
+    @property
+    def schema(self) -> Optional[str]:
+        if self.path.schema == "":
+            return get_dbt_default_schema()
+        return self.path.schema
+
+    @property
+    def project(self):
+        return self.database
+
+    def information_schema(self, identifier: Optional[str] = None) -> "MaxComputeInformationSchema":
+        return MaxComputeInformationSchema.from_relation(self, identifier)
+
+    @classmethod
+    def from_odps_table(cls, table: Table):
+        identifier = table.name
+        schema = table.get_schema()
+        schema = schema.name if schema else "default"
+
+        is_view = table.is_virtual_view or table.is_materialized_view
+
+        return cls.create(
+            database=table.project.name,
+            schema=table.get_schema().name,
+            identifier=identifier,
+            type=RelationType.View if is_view else RelationType.Table,
+        )
+
+    def render(self) -> str:
+        render_str = self.project
+        if self.schema:
+            render_str += "." + self.schema
+        if self.table:
+            render_str += "." + self.table
+        return render_str
+
+
+@dataclass(frozen=True, eq=False, repr=False)
+class MaxComputeInformationSchema(InformationSchema):
+    quote_character: str = "`"
+
+    @classmethod
+    def get_path(cls, relation: BaseRelation, information_schema_view: Optional[str]) -> Path:
+        return Path(
+            database="SYSTEM_CATALOG",
+            schema="INFORMATION_SCHEMA",
+            identifier=information_schema_view,
+        )
+
+    @classmethod
+    def get_include_policy(cls, relation, information_schema_view):
+        return relation.include_policy.replace(
+            database=True,
+            schema=True,
+            identifier=True
+        )
+
+    @classmethod
+    def get_quote_policy(
+            cls,
+            relation,
+            information_schema_view: Optional[str],
+    ) -> Policy:
+        return relation.quote_policy.replace(
+            database=False,
+            schema=False,
+            identifier=False
+        )

dbt/adapters/maxcompute/utils.py

@@ -0,0 +1,36 @@
+import time
+import functools
+
+
+def retry_on_exception(max_retries=3, delay=1, backoff=2, exceptions=(Exception,), condition=None):
+    """
+    Decorator for retrying a function if it throws an exception.
+
+    :param max_retries: Maximum number of retries before giving up.
+    :param delay: Initial delay between retries in seconds.
+    :param backoff: Multiplier applied to delay between retries.
+    :param exceptions: Tuple of exceptions to catch. Defaults to base Exception.
+    :param condition: Optional function to determine if the exception should trigger a retry.
+    """
+
+    def decorator_retry(func):
+        @functools.wraps(func)
+        def wrapper_retry(*args, **kwargs):
+            mtries, mdelay = max_retries, delay
+            while mtries > 1:
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as ex:
+                    if condition is not None and not condition(ex):
+                        raise
+                    msg = "%s, Retrying in %d seconds..." % (str(ex), mdelay)
+                    print(msg)
+                    time.sleep(mdelay)
+                    mtries -= 1
+                    mdelay *= backoff
+            return func(*args, **kwargs)
+
+        return wrapper_retry
+
+    return decorator_retry
+

dbt/adapters/maxcompute/wrapper.py

@@ -0,0 +1,63 @@
+from datetime import datetime
+from decimal import Decimal
+
+from dbt.adapters.events.logging import AdapterLogger
+from odps.dbapi import Cursor, Connection
+from odps.errors import ODPSError
+
+
+class ConnectionWrapper(Connection):
+
+    def cursor(self, *args, **kwargs):
+        return CursorWrapper(
+            self, *args, use_sqa=self._use_sqa,
+            fallback_policy=self._fallback_policy,
+            hints=self._hints, **kwargs
+        )
+
+logger = AdapterLogger("MaxCompute")
+
+class CursorWrapper(Cursor):
+
+
+
+    def execute(self, operation, parameters=None, **kwargs):
+        def replace_sql_placeholders(sql_template, values):
+            if not values:
+                return sql_template
+            if operation.count('%s') != len(parameters):
+                raise ValueError("参数数量与SQL模板中的占位符数量不匹配")
+            return operation % tuple(parameters)
+
+        def param_normalization(params):
+            if not params:
+                return None
+            normalized_params = []
+            for param in params:
+                if isinstance(param, Decimal):
+                    normalized_params.append(f"{param}BD")
+                elif isinstance(param, datetime):
+                    normalized_params.append(f"TIMESTAMP_NTZ'{param.strftime('%Y-%m-%d %H:%M:%S')}'")
+                elif isinstance(param, str):
+                    normalized_params.append(f"'{param}'")
+                else:
+                    normalized_params.append(f"{param}")
+            return normalized_params
+
+        parameters = param_normalization(parameters)
+        operation = replace_sql_placeholders(operation, parameters)
+
+        # retry three times
+        for i in range(4):
+            try:
+                super().execute(operation)
+                self._instance.wait_for_success()
+                return
+            except ODPSError as e:
+                # 0130201: view not found, 0110061: table not found
+                if e.code == "ODPS-0130201" or e.code == "ODPS-0110061":
+                    logger.info("retry when execute sql: %s, error: %s", operation, e)
+                    continue
+                else:
+                    raise e
+

dbt/include/maxcompute/__init__.py

@@ -0,0 +1,3 @@
+import os
+
+PACKAGE_PATH = os.path.dirname(__file__)

dbt/include/maxcompute/dbt_project.yml

@@ -0,0 +1,5 @@
+name: dbt_maxcompute
+version: 1.8.0
+config-version: 2
+
+macro-paths: ["macros"]

dbt/include/maxcompute/macros/adapters.sql

@@ -0,0 +1,60 @@
+/* For examples of how to fill out the macros please refer to the postgres adapter and docs
+postgres adapter macros: https://github.com/dbt-labs/dbt-core/blob/main/plugins/postgres/dbt/include/postgres/macros/adapters.sql
+dbt docs: https://docs.getdbt.com/docs/contributing/building-a-new-adapter
+*/
+
+{% macro maxcompute__truncate_relation(relation) -%}
+{% if relation.schema -%}
+    truncate table {{ relation.database }}.{{ relation.schema }}.{{ relation.identifier }};
+{%- else -%}
+    truncate table {{ relation.database }}.{{ relation.identifier }};
+{%- endif -%}
+{% endmacro %}
+
+{% macro maxcompute__rename_relation(from_relation, to_relation) -%}
+{% if from_relation.schema -%}
+    {% if from_relation.is_view -%}
+        alter view {{ from_relation.database }}.{{ from_relation.schema }}.{{ from_relation.identifier }} rename to {{ to_relation.identifier }};
+    {%- else -%}
+        alter table {{ from_relation.database }}.{{ from_relation.schema }}.{{ from_relation.identifier }} rename to {{ to_relation.identifier }};
+    {%- endif -%}
+{%- else -%}
+    {% if from_relation.is_view -%}
+        alter view {{ from_relation.database }}.{{ from_relation.identifier }} rename to {{ to_relation.identifier }}
+    {%- else -%}
+        alter table {{ from_relation.database }}.{{ from_relation.identifier }} rename to {{ to_relation.identifier }};
+    {%- endif -%}
+{%- endif -%}
+{% endmacro %}
+
+
+{% macro maxcompute__alter_column_type(relation,column_name,new_column_type) -%}
+{% if relation.schema -%}
+    alter table {{ relation.database }}.{{ relation.schema }}.{{ relation.identifier }} change {{ column_name }} {{ column_name }} {{ new_column_type }};
+{%- else -%}
+    alter table {{ relation.database }}.{{ relation.identifier }} change {{ column_name }} {{ column_name }} {{ new_column_type }};
+{%- endif -%}
+{% endmacro %}
+
+
+{% macro maxcompute__copy_grants() -%}
+    {{ return(True) }}
+{% endmacro %}
+
+
+{% macro maxcompute__create_table_as(relation, sql) -%}
+{% if relation.schema -%}
+  create table if not exists {{ relation.database }}.{{ relation.schema }}.{{ relation.identifier }} as ({{ sql }});
+{%- else -%}
+  create table if not exists {{ relation.database }}.default.{{ relation.identifier }} as ({{ sql }});
+{%- endif -%}
+{%- endmacro %}
+
+{% macro maxcompute__create_view_as(relation, sql) -%}
+{% if relation.schema -%}
+  create or replace view {{ relation.database }}.{{ relation.schema }}.{{ relation.identifier }} as ({{ sql }});
+{%- else -%}
+  create or replace view {{ relation.database }}.default.{{ relation.identifier }} as ({{ sql }});
+{%- endif -%}
+{%- endmacro %}
+

dbt/include/maxcompute/macros/catalog.sql

@@ -0,0 +1,32 @@
+{{% macro maxcompute__get_catalog(information_schema, schemas)-%}}
+
+   {{%set msg -%}}
+    get_catalog not implemented for maxcompute
+   -%}} endset {{%
+    /*
+      Your database likely has a way of accessing metadata about its objects,
+      whether by querying an information schema or by running `show` and `describe` commands.
+      dbt will use this macro to generate its catalog of objects it knows about. The catalog is one of
+      the artifacts powering the documentation site.
+      As an example, below is a simplified version of postgres__get_catalog
+    */
+
+    /*
+    
+      select {{database}} as TABLE,
+        "- set table type -"
+             when 'v' then 'VIEW'
+              else 'BASE TABLE'
+        "- set table/view names and descriptions -"
+      use several joins and search types for pulling info together, sorting etc..
+      where (
+        search if schema exists, else build
+          {%- for schema in schemas -%}
+            upper(sch.nspname) = upper('{{ schema }}'){%- if not loop.last %} or {% endif -%}
+          {%- endfor -%}
+      )
+      define any shortcut keys
+    
+    */
+  {{{{ exceptions.raise_compiler_error(msg) }}}}
+ {{% endmacro %}}

dbt/include/maxcompute/profile_template.yml

@@ -0,0 +1,14 @@
+fixed:
+  type: maxcompute
+prompts:
+  project:
+    hint: "Enter your MaxCompute project name"
+  schema:
+    hint: "Enter your MaxCompute schema name"
+  endpoint:
+    hint: "Enter your MaxCompute endpoint URL"
+  accessId:
+    hint: "Enter your accessId for MaxCompute"
+  accessKey:
+    hint: "Enter your accessKey for MaxCompute"
+    hide_input: true

dbt_maxcompute-1.8.0a0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: dbt-maxcompute
+Version: 1.8.0a0
+Summary: The MaxCompute adapter plugin for dbt
+Home-page: https://github.com/dingxin-tech/dbt-maxcompute
+Author: Alibaba Cloud MaxCompute Team
+Author-email: zhangdingxin.zdx@alibaba-inc.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: dbt-common<2.0,>=1.0.4
+Requires-Dist: dbt-adapters<2.0,>=1.1.1
+Requires-Dist: pyodps
+Requires-Dist: dbt-core>=1.8.0
+
+v<p align="center">
+  <img src="https://raw.githubusercontent.com/dbt-labs/dbt/ec7dee39f793aa4f7dd3dae37282cc87664813e4/etc/dbt-logo-full.svg" alt="dbt logo" width="500"/>
+</p>
+
+**[dbt](https://www.getdbt.com/)** enables data analysts and engineers to transform their data using the same practices that software engineers use to build applications.
+
+dbt is the T in ELT. Organize, cleanse, denormalize, filter, rename, and pre-aggregate the raw data in your warehouse so that it's ready for analysis.
+
+## MaxCompute
+This repo contains the base code to help you start to build out your dbt-maxcompute adapter plugin, for more information on how to build out the adapter please follow the [docs](https://docs.getdbt.com/docs/contributing/building-a-new-adapter)
+
+** Note ** this `README` is meant to be replaced with what information would be required to use your adpater once your at a point todo so.
+
+** Note **
+### Adapter Scaffold default Versioning
+This adapter plugin follows [semantic versioning](https://semver.org/). The first version of this plugin is v1.7.0, in order to be compatible with dbt Core v1.7.0.
+
+It's also brand new! For MaxCompute-specific functionality, we will aim for backwards-compatibility wherever possible. We are likely to be iterating more quickly than most major-version-1 software projects. To that end, backwards-incompatible changes will be clearly communicated and limited to minor versions (once every three months).
+
+ ## Getting Started
+
+ #### Setting up Locally
+- run `pip install -r dev-requirements.txt`.
+- cd directory into the `dbt-core` you'd like to be testing against and run `make dev`.
+
+ #### Connect to Github
+- run `git init`.
+- Connect your lcoal code to a Github repo.
+
+## Join the dbt Community
+
+- Be part of the conversation in the [dbt Community Slack](http://community.getdbt.com/)
+- If one doesn't exist feel free to request a #db-MaxCompute channel be made in the [#channel-requests](https://getdbt.slack.com/archives/C01D8J8AJDA) on dbt community slack channel.
+- Read more on the [dbt Community Discourse](https://discourse.getdbt.com)
+
+## Reporting bugs and contributing code
+
+- Want to report a bug or request a feature? Let us know on [Slack](http://community.getdbt.com/), or open [an issue](https://github.com/dbt-labs/dbt-redshift/issues/new)
+- Want to help us build dbt? Check out the [Contributing Guide](https://github.com/dbt-labs/dbt/blob/HEAD/CONTRIBUTING.md)
+
+## Code of Conduct
+
+Everyone interacting in the dbt project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [dbt Code of Conduct](https://community.getdbt.com/code-of-conduct).

dbt_maxcompute-1.8.0a0.dist-info/RECORD

@@ -0,0 +1,18 @@
+dbt/adapters/maxcompute/__init__.py,sha256=dOzJefbPsSIjnwrT3SBcU6e0u0p96dIsv9Z1dxl-_80,435
+dbt/adapters/maxcompute/__version__.py,sha256=xM40SuOoM9AJfLTVSWDAmrxWWVMuif9OhwoYDgF0AVU,24
+dbt/adapters/maxcompute/column.py,sha256=Ui89ZcOMVp8Z-_Nzg4kQ-2rUtD3k-B5i6NWpXO8x6I8,2054
+dbt/adapters/maxcompute/connections.py,sha256=jap7HGUPKG3hz1uypK4TL9P-s_GZmmFYZ2qKvpGYIq0,3055
+dbt/adapters/maxcompute/context.py,sha256=ta4hzT_uQ-GkalINXSuzk1SDsfkJdERLgZv1PLqHhLM,333
+dbt/adapters/maxcompute/impl.py,sha256=8JMTYGlkkNkOSmVkr9z8qyQu4L97rX7_HptVy0eGMJU,10203
+dbt/adapters/maxcompute/relation.py,sha256=YmBOLo-ElSam4sQO3HJvH5LPU7WM8Iuwf5m-gjmJjh0,3420
+dbt/adapters/maxcompute/utils.py,sha256=4gm7dQC0HmrtiP9qhayQ5sU3rOBykNZKWeLEEwcB29o,1293
+dbt/adapters/maxcompute/wrapper.py,sha256=VVxba2UQOCK5r8PIqVT3zCN3Err1GlJK7PsqZlHPw8U,2196
+dbt/include/maxcompute/__init__.py,sha256=vBGWeG-dHHkimfnX8axBJ4IgAowFw8xADmo6Auzn2xc,52
+dbt/include/maxcompute/dbt_project.yml,sha256=Zy2C6E5NH79TU4RSbsprrGaIuQStdhN8KI0p8hoRj-w,79
+dbt/include/maxcompute/profile_template.yml,sha256=RiKzLQrzByTbKssmOVCi7uCu1aSrMyprKl1ab7Gp6dE,349
+dbt/include/maxcompute/macros/adapters.sql,sha256=nrqQJz4yDFB54govWVdqftSkGgcuJb6i5erCqcOLWqY,2601
+dbt/include/maxcompute/macros/catalog.sql,sha256=0t0ud_E98iKQ0dNK3p1DMJ8GiksQPHSQ4yhjFdLM_Ng,1184
+dbt_maxcompute-1.8.0a0.dist-info/METADATA,sha256=rFtkNJHvRP8kxfMrap1--Fd06b_eco3c9JtZf5lbSxs,3613
+dbt_maxcompute-1.8.0a0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+dbt_maxcompute-1.8.0a0.dist-info/top_level.txt,sha256=B2YH4he17ajilEWOGCKHbRcEJlCuZKwCcgFcLPntLsE,4
+dbt_maxcompute-1.8.0a0.dist-info/RECORD,,

dbt_maxcompute-1.8.0a0.dist-info/WHEEL

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

dbt_maxcompute-1.8.0a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dbt