dbt-adapters 1.4.1__tar.gz → 1.6.0__tar.gz

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.4.1
+Version: 1.6.0
 Summary: The set of adapter protocols and base functionality that supports integration with dbt-core
 Project-URL: Homepage, https://github.com/dbt-labs/dbt-adapters
 Project-URL: Documentation, https://docs.getdbt.com
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8.0
 Requires-Dist: agate<2.0,>=1.0
-Requires-Dist: dbt-common<2.0,>=1.6
+Requires-Dist: dbt-common<2.0,>=1.8
 Requires-Dist: mashumaro[msgpack]<4.0,>=3.0
 Requires-Dist: protobuf<5.0,>=3.0
 Requires-Dist: pytz>=2015.7

dbt_adapters-1.6.0/dbt/adapters/__about__.py

@@ -0,0 +1 @@
+version = "1.6.0"

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/adapters/base/impl.py

@@ -24,6 +24,7 @@ from typing import (
 )
 
 import pytz
+from dbt_common.behavior_flags import Behavior, BehaviorFlag
 from dbt_common.clients.jinja import CallableMacroGenerator
 from dbt_common.contracts.constraints import (
     ColumnLevelConstraint,
@@ -54,7 +55,7 @@ from dbt.adapters.base.connections import (
     BaseConnectionManager,
     Connection,
 )
-from dbt.adapters.base.meta import AdapterMeta, available
+from dbt.adapters.base.meta import AdapterMeta, available, available_property
 from dbt.adapters.base.relation import (
     BaseRelation,
     ComponentName,
@@ -261,7 +262,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     MAX_SCHEMA_METADATA_RELATIONS = 100
 
-    # This static member variable can be overriden in concrete adapter
+    # This static member variable can be overridden in concrete adapter
     # implementations to indicate adapter support for optional capabilities.
     _capabilities = CapabilityDict({})
 
@@ -271,6 +272,8 @@ class BaseAdapter(metaclass=AdapterMeta):
         self.connections = self.ConnectionManager(config, mp_context)
         self._macro_resolver: Optional[MacroResolverProtocol] = None
         self._macro_context_generator: Optional[MacroContextGeneratorCallable] = None
+        # this will be updated to include global behavior flags once they exist
+        self.behavior = []  # type: ignore
 
     ###
     # Methods to set / access a macro resolver
@@ -291,6 +294,27 @@ class BaseAdapter(metaclass=AdapterMeta):
     ) -> None:
         self._macro_context_generator = macro_context_generator
 
+    @available_property
+    def behavior(self) -> Behavior:
+        return self._behavior
+
+    @behavior.setter  # type: ignore
+    def behavior(self, flags: List[BehaviorFlag]) -> None:
+        flags.extend(self._behavior_flags)
+        try:
+            # we don't always get project flags, for example during `dbt debug`
+            self._behavior = Behavior(flags, self.config.flags)
+        except AttributeError:
+            # in that case, don't load any behavior to avoid unexpected defaults
+            self._behavior = Behavior([], {})
+
+    @property
+    def _behavior_flags(self) -> List[BehaviorFlag]:
+        """
+        This method should be overwritten by adapter maintainers to provide platform-specific flags
+        """
+        return []
+
     ###
     # Methods that pass through to the connection manager
     ###
@@ -1549,7 +1573,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         return ["append"]
 
     def builtin_incremental_strategies(self):
-        return ["append", "delete+insert", "merge", "insert_overwrite"]
+        return ["append", "delete+insert", "merge", "insert_overwrite", "microbatch"]
 
     @available.parse_none
     def get_incremental_strategy_macro(self, model_context, strategy: str):

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/adapters/base/meta.py

@@ -92,6 +92,25 @@ class _Available:
 available = _Available()
 
 
+class available_property(property):
+    """
+    This supports making dynamic properties (`@property`) available in the jinja context.
+
+    We use `@available` to make methods available in the jinja context, but this mechanism relies on the method being callable.
+    Intuitively, we should be able to use both `@available` and `@property` to create a dynamic property that's available in the jinja context.
+
+    Using the `@property` decorator as the inner decorator supplies `@available` with something that is not callable.
+    Instead of returning the method, `@property` returns the value itself, not the method that is called to create the value.
+
+    Using the `@available` decorator as the inner decorator adds `_is_available_ = True` to the function.
+    However, when the `@property` decorator executes, it returns a `property` object which does not have the `_is_available_` attribute.
+
+    This decorator solves this problem by simply adding `_is_available_ = True` as an attribute on the `property` built-in.
+    """
+
+    _is_available_ = True
+
+
 class AdapterMeta(abc.ABCMeta):
     _available_: FrozenSet[str]
     _parse_replacements_: Dict[str, Callable]

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/adapters/base/relation.py

@@ -1,5 +1,6 @@
 from collections.abc import Hashable
 from dataclasses import dataclass, field
+from datetime import datetime
 from typing import (
     Any,
     Dict,
@@ -36,6 +37,13 @@ Self = TypeVar("Self", bound="BaseRelation")
 SerializableIterable = Union[Tuple, FrozenSet]
 
 
+@dataclass
+class EventTimeFilter(FakeAPIObject):
+    field_name: str
+    start: Optional[datetime] = None
+    end: Optional[datetime] = None
+
+
 @dataclass(frozen=True, eq=False, repr=False)
 class BaseRelation(FakeAPIObject, Hashable):
     path: Path
@@ -47,6 +55,7 @@ class BaseRelation(FakeAPIObject, Hashable):
     quote_policy: Policy = field(default_factory=lambda: Policy())
     dbt_created: bool = False
     limit: Optional[int] = None
+    event_time_filter: Optional[EventTimeFilter] = None
     require_alias: bool = (
         True  # used to govern whether to add an alias when render_limited is called
     )
@@ -208,14 +217,19 @@ class BaseRelation(FakeAPIObject, Hashable):
         # if there is nothing set, this will return the empty string.
         return ".".join(part for _, part in self._render_iterator() if part is not None)
 
-    def _render_limited_alias(self) -> str:
+    def _render_subquery_alias(self, namespace: str) -> str:
         """Some databases require an alias for subqueries (postgres, mysql) for all others we want to avoid adding
         an alias as it has the potential to introduce issues with the query if the user also defines an alias.
         """
         if self.require_alias:
-            return f" _dbt_limit_subq_{self.table}"
+            return f" _dbt_{namespace}_subq_{self.table}"
         return ""
 
+    def _render_limited_alias(
+        self,
+    ) -> str:
+        return self._render_subquery_alias(namespace="limit")
+
     def render_limited(self) -> str:
         rendered = self.render()
         if self.limit is None:
@@ -225,6 +239,31 @@ class BaseRelation(FakeAPIObject, Hashable):
         else:
             return f"(select * from {rendered} limit {self.limit}){self._render_limited_alias()}"
 
+    def render_event_time_filtered(self, rendered: Optional[str] = None) -> str:
+        rendered = rendered or self.render()
+        if self.event_time_filter is None:
+            return rendered
+
+        filter = self._render_event_time_filtered(self.event_time_filter)
+        if not filter:
+            return rendered
+
+        return f"(select * from {rendered} where {filter}){self._render_subquery_alias(namespace='et_filter')}"
+
+    def _render_event_time_filtered(self, event_time_filter: EventTimeFilter) -> str:
+        """
+        Returns "" if start and end are both None
+        """
+        filter = ""
+        if event_time_filter.start and event_time_filter.end:
+            filter = f"{event_time_filter.field_name} >= '{event_time_filter.start}' and {event_time_filter.field_name} < '{event_time_filter.end}'"
+        elif event_time_filter.start:
+            filter = f"{event_time_filter.field_name} >= '{event_time_filter.start}'"
+        elif event_time_filter.end:
+            filter = f"{event_time_filter.field_name} < '{event_time_filter.end}'"
+
+        return filter
+
     def quoted(self, identifier):
         return "{quote_char}{identifier}{quote_char}".format(
             quote_char=self.quote_character,
@@ -240,6 +279,7 @@ class BaseRelation(FakeAPIObject, Hashable):
         cls: Type[Self],
         relation_config: RelationConfig,
         limit: Optional[int] = None,
+        event_time_filter: Optional[EventTimeFilter] = None,
     ) -> Self:
         # Note that ephemeral models are based on the identifier, which will
         # point to the model's alias if one exists and otherwise fall back to
@@ -250,6 +290,7 @@ class BaseRelation(FakeAPIObject, Hashable):
             type=cls.CTE,
             identifier=identifier,
             limit=limit,
+            event_time_filter=event_time_filter,
         ).quote(identifier=False)
 
     @classmethod
@@ -315,7 +356,14 @@ class BaseRelation(FakeAPIObject, Hashable):
         return hash(self.render())
 
     def __str__(self) -> str:
-        return self.render() if self.limit is None else self.render_limited()
+        rendered = self.render() if self.limit is None else self.render_limited()
+
+        # Limited subquery is wrapped by the event time filter subquery, and not the other way around.
+        # This is because in the context of resolving limited refs, we care more about performance than reliably producing a sample of a certain size.
+        if self.event_time_filter:
+            rendered = self.render_event_time_filtered(rendered)
+
+        return rendered
 
     @property
     def database(self) -> Optional[str]:

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/adapters/factory.py

@@ -188,7 +188,7 @@ class AdapterContainer:
     def get_adapter_type_names(self, name: Optional[str]) -> List[str]:
         return [p.adapter.type() for p in self.get_adapter_plugins(name)]
 
-    def get_adapter_constraint_support(self, name: Optional[str]) -> List[str]:
+    def get_adapter_constraint_support(self, name: Optional[str]) -> Dict[str, str]:
         return self.lookup_adapter(name).CONSTRAINT_SUPPORT  # type: ignore
 
 
@@ -251,7 +251,7 @@ def get_adapter_type_names(name: Optional[str]) -> List[str]:
     return FACTORY.get_adapter_type_names(name)
 
 
-def get_adapter_constraint_support(name: Optional[str]) -> List[str]:
+def get_adapter_constraint_support(name: Optional[str]) -> Dict[str, str]:
     return FACTORY.get_adapter_constraint_support(name)
 
 

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/include/global_project/macros/adapters/timestamps.sql

@@ -15,6 +15,14 @@
     {{ current_timestamp() }}
 {% endmacro %}
 
+{% macro get_snapshot_get_time_data_type() %}
+    {% set snapshot_time = adapter.dispatch('snapshot_get_time', 'dbt')() %}
+    {% set time_data_type_sql = 'select ' ~ snapshot_time ~ ' as dbt_snapshot_time' %}
+    {% set snapshot_time_column_schema = get_column_schema_from_query(time_data_type_sql) %}
+    {% set time_data_type = snapshot_time_column_schema[0].dtype %}
+    {{ return(time_data_type or none) }}
+{% endmacro %}
+
 ---------------------------------------------
 
 /* {#

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/include/global_project/macros/materializations/models/incremental/strategies.sql

@@ -66,6 +66,19 @@
 {% endmacro %}
 
 
+{% macro get_incremental_microbatch_sql(arg_dict) %}
+
+  {{ return(adapter.dispatch('get_incremental_microbatch_sql', 'dbt')(arg_dict)) }}
+
+{% endmacro %}
+
+{% macro default__get_incremental_microbatch_sql(arg_dict) %}
+
+  {{ exceptions.raise_not_implemented('microbatch materialization strategy not implemented for adapter ' + adapter.type()) }}
+
+{% endmacro %}
+
+
 {% macro get_insert_into_sql(target_relation, temp_relation, dest_columns) %}
 
     {%- set dest_cols_csv = get_quoted_csv(dest_columns | map(attribute="name")) -%}

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/include/global_project/macros/materializations/snapshots/helpers.sql

@@ -179,3 +179,28 @@
 
     {% do return(temp_relation) %}
 {% endmacro %}
+
+
+{% macro get_updated_at_column_data_type(snapshot_sql) %}
+    {% set snapshot_sql_column_schema = get_column_schema_from_query(snapshot_sql) %}
+    {% set dbt_updated_at_data_type = null %}
+    {% set ns = namespace() -%} {#-- handle for-loop scoping with a namespace --#}
+    {% set ns.dbt_updated_at_data_type = null -%}
+    {% for column in snapshot_sql_column_schema %}
+    {%   if ((column.column == 'dbt_updated_at') or (column.column == 'DBT_UPDATED_AT')) %}
+    {%     set ns.dbt_updated_at_data_type = column.dtype %}
+    {%   endif %}
+    {% endfor %}
+    {{ return(ns.dbt_updated_at_data_type or none)  }}
+{% endmacro %}
+
+
+{% macro check_time_data_types(sql) %}
+  {% set dbt_updated_at_data_type = get_updated_at_column_data_type(sql) %}
+  {% set snapshot_get_time_data_type = get_snapshot_get_time_data_type() %}
+  {% if snapshot_get_time_data_type is not none and dbt_updated_at_data_type is not none and snapshot_get_time_data_type != dbt_updated_at_data_type %}
+  {%   if exceptions.warn_snapshot_timestamp_data_types %}
+  {{     exceptions.warn_snapshot_timestamp_data_types(snapshot_get_time_data_type, dbt_updated_at_data_type) }}
+  {%   endif %}
+  {% endif %}
+{% endmacro %}

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/dbt/include/global_project/macros/materializations/snapshots/snapshot.sql

@@ -29,12 +29,14 @@
   {% if not target_relation_exists %}
 
       {% set build_sql = build_snapshot_table(strategy, model['compiled_code']) %}
+      {% set build_or_select_sql = build_sql %}
       {% set final_sql = create_table_as(False, target_relation, build_sql) %}
 
   {% else %}
 
       {{ adapter.valid_snapshot_target(target_relation) }}
 
+      {% set build_or_select_sql = snapshot_staging_table(strategy, sql, target_relation) %}
       {% set staging_table = build_snapshot_staging_table(strategy, sql, target_relation) %}
 
       -- this may no-op if the database does not require column expansion
@@ -71,6 +73,9 @@
 
   {% endif %}
 
+
+  {{ check_time_data_types(build_or_select_sql) }}
+
   {% call statement('main') %}
       {{ final_sql }}
   {% endcall %}

{dbt_adapters-1.4.1 → dbt_adapters-1.6.0}/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    "dbt-common>=1.6,<2.0",
+    "dbt-common>=1.8,<2.0",
     "pytz>=2015.7",
     # installed via dbt-common but used directly
     "agate>=1.0,<2.0",

dbt_adapters-1.4.1/dbt/adapters/__about__.py

@@ -1 +0,0 @@
-version = "1.4.1"