dbt Makroları: Kapsamlı Bir Rehber

Analitik mühendisliğinde, dbt (data build tool) makroları, tekrar kullanılabilir kod blokları aracılığıyla dinamik, yeniden kullanılabilir SQL mantığı yazmanın güçlü bir yolunu sunar. 

Bu eğitimde, dbt makrolarının temellerini, onları Jinja kullanarak nasıl oluşturacağımızı, sürdürülebilirlik için en iyi uygulamaları ve gerçek dünya uygulamalarını, hepsi kod örnekleriyle birlikte ele alacağız. 

dbt Makroları Nedir?

dbt makroları, dbt içinde Jinja şablonlama dili kullanılarak yazılmış, SQL’i dinamik olarak üretmenizi sağlayan tekrar kullanılabilir kod bloklarıdır. Tekrarı azaltır ve dönüşüm mantığını merkezileştirirler. 

Bu makrolar, geleneksel programlama dillerindeki fonksiyonlar gibi çalışır.

Örneğin, bir metriği birden fazla modelde hesaplamanız gerekiyorsa, bir makro bu hesaplamayı kapsülleyerek bakımı ve güncellemeyi kolaylaştırır.

Makrolar ayrıca dbt-utils gibi paketlerde de saklanabilir.

Neden dbt Makroları Kullanılmalı?

Makroların başlıca birkaç avantajı vardır:

• Yinelemeyi azaltır: Mantık bloğunu bir kez yazıp her yerde yeniden kullanabilirsiniz.
• Tutarlılık: Aynı dönüşüm mantığını modeller arasında elle kopyalamadan uygulama.
• Esneklik: Makrolar parametreleri destekler ve çeşitli girdilere uyum sağlar.
• Projeler arası paylaşım: İyi tasarlanmış makrolar paketler olarak paylaşılabilir.

Bu faydalar, daha temiz, daha sürdürülebilir ve ölçeklenebilir kod tabanlarına yol açar.

dbt Makro Temel Kavramları

Makroların dbt’de nasıl çalıştığını anlamanıza yardımcı olmak için bazı kilit kavramlara bakalım.

1. Yeniden kullanılabilirlik

Makrolar, bir parça SQL mantığını bir kez tanımlayıp birden fazla model, test veya hatta diğer makrolar arasında yeniden kullanmanıza olanak tanır.

2. Jinja şablon motoru

Jinja’nın dbt ile entegrasyonu, veritabanına ulaşmadan önce değişkenler eklemenizi, koşullar uygulamanızı ve listeler üzerinde döngü kurmanızı mümkün kılar. dbt bu şablonu ham SQL’e derler; böylece makrolar veritabanından bağımsız olur.

3. Programlama tekniklerinin devreye girişi

Makrolar SQL’i programlanabilir bir çerçeveye dönüştürebilir. Mantık, döngüler ve koşullara izin verirler—bunlar standart SQL’in esnek şekilde ele alamadığı yaygın özelliklerdir.

Fonksiyonlara benzer şekilde, dbt’deki makrolar argümanlar (parametreler) alabilir ve farklı girdilerle çağrıldığında farklı çıktılar üretebilir. Karmaşık dönüşümleri daha küçük, yeniden kullanılabilir birimlere bölerek basitleştirirler. 

Jinja ile Makro Oluşturma

Şimdi, kendimiz için bazı makrolar nasıl oluşturabiliriz görelim.

Jinja, dbt makrolarını çalıştıran şablon motorudur ve SQL’i dinamik, programlanabilir metin olarak ele almanızı sağlar. 

Şablon yapıları ve sınırlayıcılar

Jinja’yı kullanmak için belirli şablon yapıları ve sınırlayıcılar kullanmanız gerekir.

İşte bazı yaygın yapılar ve sınırlayıcılar:

• İfadeler {{ }}: İfadeleri ekler.
• İfadeler {% %}: Deyimleri yürütür.
• Yorumlar {# #}: dbt’nin yok saymasını istediğiniz yorumları ekler.

Makrolarda, {{ ... }} bir değer üretmesi gereken ifadeler (ör. sütun adları veya hesaplamalar) için kullanılırken, {% ... %} kontrol akışı (döngüler, if/else deyimleri, makro tanımları) için kullanılır. Jinja yorumları {# ... #} kullanır ve derleme sırasında tamamen kaldırılır.

İşte makrolarda kullanılan deyimlerin sözdizimine bir örnek:

{% macro your_macro_name(your_variable) %}
    select 'Hello, {{ your_variable}}' as greeting
{% endmacro %}Altyapı:

Deyimleri kullanarak bir makro oluşturma örneği:

{% macro greet(name) %}
    select 'Hello, {{ name }}' as greeting
{% endmacro %}Altyapı:

Makroyu çalıştırmak için şunu kullanın:

dbt run-operation greet(name) --args 'Austin'Altyapı:

Değişken yönetimi

Makrolara değişkenler geçirebilir veya bunları makro içinde tanımlayabilirsiniz. upper veya lower gibi filtreler metin değerlerini dönüştürebilir.

Tüm metin değerlerini büyük harfe çevirmek için upper fonksiyonunun bir uygulaması aşağıdadır. 

{% macro to_upper_case(column_name) %}
    upper({{ column_name }})
{% endmacro %}Altyapı:

Bunu uygulamak için, yeni oluşturulan makroyu dbt modelinizde çağırmanız/başvurmanız gerekir.

İşte bir kod örneği:

SELECT
    id,
    {{ to_upper_case('product_name') }} AS product_name_upper
FROM {{ source('public', 'orders') }}Altyapı:

Kontrol yapıları

Ardından, programlama dillerine benzer şekilde, dbt makroları şunları sunabilir:

• Koşullu deyimler ({% if %} / {% endif %}):
• Döngüler ({% for %} / {% endfor %}) 

Bu yapılar, girdilere bağlı olarak SQL ifadelerini dinamik olarak oluşturmanıza veya birden çok ifadeyi üretmenize olanak tanır.

Bu da makroların karmaşık SQL üretim görevlerini daha kolay ele almasını sağlar.

Parametre yönetimi ve hata yönetimi

Makrolar, çalışma zamanı sorunlarını önlemek için derleme aşamasında girdileri doğrulayabilir ve hatalar oluşturabilir.

Parametreler, programlama dillerindeki fonksiyon tanımlarına benzer şekilde () parantezleri kullanılarak makro bildiriminde tanımlanır.

İki parametreyi nasıl dahil edebileceğimize bir örnek:

{% macro my_macro(param1, param2) %}
    SELECT
        {{ param1 }},
        {{ param2 }}
    FROM my_table
{% endmacro %}Altyapı:

Gördüğünüz gibi, ilk satırda hem param1 hem de param2’yi ekledik.

Bir dbt modelinde makroyu çağırmak için çift süslü parantez {{ }} kullanmalısınız. Parametreler parantez içinde argüman olarak geçirilir.

SELECT
    id,
    {{ my_macro('column_a', 'column_b') }}
FROM my_source_tableAltyapı:

Bu durumda, parametrelerimiz olarak hem column_a hem de column_b’yi belirttik.

dbt Makrolarıyla Çalışmak için Kurulum Rehberi

Makroları oluşturmaya ve kullanmaya başlamadan önce, bu eğitimdeki örnekleri takip edebilmeniz için bir çalışma ortamı kuralım. 

Bu, dbt’nin kurulu olmasını, örnek bir veri kümesinin yüklenmesini ve makrolar oluşturmak için doğru klasör yapısına sahip olmanızı sağlar.

1. dbt Core’u kurun

dbt Core’u yerel olarak kurmanız gerekir. Bu eğitimde Postgres kullanıyorsanız, şu komutla kurun:

pip install dbtAltyapı:

Projeniz bir veri ambarı kullanıyorsa, bunun yerine ilgili komutları çalıştırın:

pip install dbt-core dbt-postgres

pip install dbt-core dbt-snowflake

pip install dbt-core dbt-bigqueryAltyapı:

2. Bir dbt Projesi oluşturun

Herhangi bir dbt komutunu çalıştırmadan önce bir proje ortamı kurmamız gerekecek.

İstediğiniz projeler dizinine gidin.

Burası dbt proje dosyalarınızı saklayacağınız yerdir. Bu örnekte, ilgili tüm dosyaları bu dbt proje klasöründe saklayacağız.

Bir dbt projesini başlatmak için şunu çalıştırmanız gerekir:

dbt initAltyapı:

cd ~/dbt-macros-tutorialAltyapı:

Şu biçimde bir klasör yapısı oluşturun:

macros_tutorial/
  ├─ models/
  ├─ macros/
  ├─ tests/
  ├─ seeds/
  ├─ dbt_project.ymlAltyapı:

3. Örnek Veri Küməsini Hazırlayın

Postgres’e (veya seçtiğiniz ambarınıza) yüklemek üzere küçük bir siparişler veri kümesi oluşturmak için Python kullanacağız.

import pandas as pd
import random
from datetime import datetime, timedelta
from sqlalchemy import create_engine

# Create sample orders dataframe
random.seed(42)
num_rows = 20
start_date = datetime(2025, 1, 1)

data = []
for i in range(1, num_rows + 1):
    order_date = start_date + timedelta(days=random.randint(0, 30))
    ship_date = order_date + timedelta(days=random.randint(1, 10))
    data.append({
        'order_id': i,
        'customer_id': random.randint(100, 105),
        'order_date': order_date.date(),
        'ship_date': ship_date.date(),
        'status': random.choice(['pending', 'shipped', 'delivered']),
        'revenue': round(random.uniform(50, 500), 2),
        'cost': round(random.uniform(20, 400), 2)
    })

df = pd.DataFrame(data)

# Load into Postgres
engine = create_engine('postgresql://user:password@localhost:5432/dbt_demo')
df.to_sql('orders', engine, if_exists='replace', index=False)Altyapı:

Not: Veritabanınız için bağlantı dizesini güncelleyin.

4. dbt’de Bir Kaynak Oluşturun

models/src_orders.yml dosyasına şunları ekleyin:

version: 2
sources:
  - name: public
schema: public

    tables:
      - name: ordersAltyapı:

5. Bağlantıyı ve Kaynağı Test Edin

dbt debug

dbt run-operation list_relations --args '{"schema_name": "public"}'Altyapı:

Artık bu veri kümesi üzerinde çalışan makrolar yazmaya hazırsınız.

dbt Makroları Nasıl Yazılır ve Kullanılır

Şimdi, kendi makrolarımızı yazmayı deneyelim.

Makroların tanımlanması

Makro tanımlarını macros/ dizini altındaki .sql dosyalarına yerleştirin.

Makro adlandırırken, her makroya amacını yansıtan açıklayıcı bir ad verin ve esnek olması için parametreler kullanın. Üstte kısa bir docstring yorumu eklemek ekip arkadaşlarının amacını anlamasına yardımcı olur.

İşte bir örnek:

    -- macros/my_macro.sql
    {% macro cents_to_dollars(column_name, precision=2) %}
        ({{ column_name }} / 100.0)::numeric(18, {{ precision }})
    {% endmacro %}Altyapı:

Modellerde makroları çağırma

Modeller içinde makroları {{ macro_name(arg1, arg2) }} ile çağırırsınız. SELECT ifadelerinde, WHERE filtrelerinde veya tüm CTE bloklarında kullanılabilirler; böylece tekrar kullanılabilir SQL kalıplarını her yere enjekte edebilirsiniz.

İşte bir örnek:

    -- models/my_model.sql
    SELECT
        order_id,
        {{ cents_to_dollars('amount_in_cents') }} AS amount_in_dollars,
        {{ cents_to_dollars('tax_in_cents', precision=4) }} AS tax_in_dollars
    FROM {{ ref('raw_orders') }}Altyapı:

CLI’dan makroları çağırma

Model derlemeleri dışındaki operasyonel görevler için şu biçim/sözdizimini kullanın:

dbt run-operation macro_name --args '{"param": "value"}'Altyapı:

Bu, bir model oluşturmadan şema oluşturma veya veri temizliği gibi yardımcı SQL’leri çalıştırmanızı sağlar.

İşte bir komut örneği:

dbt run-operation greet --args '{"name": "Austin"}'Altyapı:

Paketlerden makro kullanma

Makrolar, dbt’de dbt-utils gibi paketlerden de gelebilir.

packages.yml üzerinden bir paket kurduğunuzda, makroları hemen kullanılabilir hale gelir. Bunu yapmak için dbt deps çalıştırmanız gerekir.

Ardından yeni eklenen makroları şu biçimle çağırabilirsiniz: package_name.macro_name.

Makro dosya organizasyonu

Daha iyi bir organizasyon için, sürdürülebilirliği artırmak üzere makroları işlevselliğe göre ayırıp düzenleyin. 

İlgili makroları ayrı dosyalarda (ör. date_utils.sql, string_utils.sql) gruplayın. Bu, zaman içinde mantığı bulmayı ve güncellemeyi kolaylaştırır.

Uygulamada dbt Makrolarına Örnekler

Makroların daha pratik kullanım örneklerinden bazıları şunlardır:

Tarih karşılaştırma makrosu

Diyelim ki tarihleri karşılaştırmak için sık kullanacağınız bir fonksiyon oluşturmak istiyorsunuz.

Bu durumda, SQL lehçe farklılıklarını ele alırken iki tarih alanı arasındaki gün farkını hesaplamak için bir makro kullanabilirsiniz.

macros/date_utils.sql konumunda yeni bir dosya oluşturarak başlayın.

Ardından aşağıdaki kodu kullanın:

{% macro days_between(start_col, end_col) %}
    {#-- Handle different warehouses --#}
    {% if target.type in ['postgres', 'redshift'] %}
        (DATE_PART('day', {{ end_col }}::timestamp - {{ start_col }}::timestamp))
    {% elif target.type in ['snowflake'] %}
        DATEDIFF('day', {{ start_col }}, {{ end_col }})
    {% elif target.type in ['bigquery'] %}
        DATE_DIFF(CAST({{ end_col }} AS DATE), CAST({{ start_col }} AS DATE), DAY)
    {% else %}
        -- Fallback to ANSI-ish expression; may need adjustment per engine
        CAST({{ end_col }} AS DATE) - CAST({{ start_col }} AS DATE)
    {% endif %}
{% endmacro %}Altyapı:

Şimdi bu yeni days_between makrosunu bir modelde kullanacağız.

with src as (
  select * from {{ source('public', 'orders') }}
)
select
  order_id,
  customer_id,
  order_date,
  ship_date,
  {{ days_between('order_date', 'ship_date') }} as days_to_ship
from srcAltyapı:

Özelleştirilmiş generate_schema_name makrosu

Varsayılan olarak, dbt generate_schema_name adlı bir varsayılan makro kullanır. Bu makro, bir modelin oluşturulacağı şemanın adını belirtmek için kullanılır.

Kullanılan şemayı ortama göre kontrol etmek için dbt’nin varsayılanını da geçersiz kılabilirsiniz.

Bu dosyayı şu konuma ekleyebilirsiniz: macros/generate_schema_name.sql.

`sql
{% macro generate_schema_name(custom_schema_name, node) -%}
    {# Policy:
       - prod:    ANALYTICS
       - nonprod: dev_analytics, ci_analytics, etc.
    #}
    {%- if target.name == 'prod' -%}
        {{ custom_schema_name | trim }}
    {%- else -%}
        {{ (target.name ~ '_' ~ custom_schema_name) | lower | replace(' ', '_') }}
    {%- endif -%}
{%- endmacro %}Altyapı:

Nasıl yardımcı olur: dev ortamında, modeller dev_analytics (izolasyon) ortamına yerleşir. prod ortamında ise analytics’e yerleşirler. Bu, öngörülebilir ve çakışmasız dağıtımlar oluşturur.

Bir modelin dışında SQL yürütme

Modellerin dışında, tablo temizliği veya meta veri güncellemeleri gibi işlemler için SQL komutları da çalıştırabilirsiniz; bunun için model oluşturmanız gerekmez.

Ham SQL çalıştıran bir makro yazabilir ve ardından dbt run-operation ile çalıştırabilirsiniz.

Bu, bir modelin kapsamına uymayan DDL (tablo düşürme/oluşturma) veya meta veri güncellemeleri için kullanışlıdır.

İşte makro:

{% macro cleanup_temp_tables() %}
    {% set sql %}
        drop table if exists {{ target.schema }}.temp_table;
        delete from {{ target.schema }}.audit_log where event_type = 'test';
    {% endset %}
    {{ run_query(sql) }}
{% endmacro %}Altyapı:

Ardından, bu işlemi terminalde çalıştırın:

dbt run-operation cleanup_temp_tablesAltyapı:

Bu, makroları modellerin içine dahil etmeden çalıştırmanıza olanak tanır.

Parametreli makro örneği

Bir fonksiyonda olduğu gibi, yüksek derecede parametreleştirilmiş bir makro da oluşturabiliriz. 

Bu örnekte, değerler sağlandığında belirli bir duruma göre kayıtları filtreleyeceğiz. Bu, mantık oluşturmak için if ve do deyimlerini kullanır.

{% macro where_orders(status=None, min_date=None, max_date=None) %}
  {%- set clauses = [] -%}
  {%- if status is not none -%}
    {%- do clauses.append("status = '" ~ status ~ "'") -%}
  {%- endif -%}
  {%- if min_date is not none -%}
    {%- do clauses.append("order_date >= '" ~ min_date ~ "'") -%}
  {%- endif -%}
  {%- if max_date is not none -%}
    {%- do clauses.append("order_date < '" ~ max_date ~ "'") -%}
  {%- endif -%}
  {%- if clauses | length > 0 -%}
    where {{ clauses | join(' and ') }}
  {%- endif -%}
{% endmacro %}Altyapı:

Şimdi bu makroyu bir modelde uyguluyoruz:

with src as (
  select * from {{ ref('orders') }}
)
select *
from src
{{ where_orders(status='shipped', min_date='2025-01-05') }}Altyapı:

Bu makro, bir argüman atlandığında o ölçütün yok sayılacağı şekilde mantık içerir. Bu, isteğe bağlı mantığı derli toplu tutar.

dbt Makroları için En İyi Uygulamalar

Harika makrolar tasarlamak, SQL’in derlenmesinden daha fazlasıdır. En iyi makrolar keşfedilebilir, iyi belgelenmiş, öngörülebilir, test edilebilir ve kolayca kullanım dışı bırakılabilir veya genişletilebilir olmalıdır. 

İzlemeniz gereken bazı en iyi uygulamalar şunlardır:

1. Adlandırma kuralları ve parametre tasarımı

SQL ve programlama dillerinde olduğu gibi, okunabilirliği sağlamak için adlandırma kurallarına uyulmalıdır.

Bazı adlandırma ipuçları:

• Açık ve eylem odaklı olun. helper gibi belirsiz adlar yerine generate_select_list, where_orders gibi fiiller veya net niyetleri tercih edin.
• Adları sabit ve küçük harfli tutun. Yılan biçimi (snake_case) ve alana göre sabit önekler kullanın; ör. date_*, string_*, test_*, admin_*.

2. Belgelendirme stratejileri

Oluşturduklarınızı belgelemenize yardımcı olacak alışkanlıklar geliştirmelisiniz. Belgeler, geliştiricilerin baktığı yerlerde olmalıdır. 

Örneğin, satır içi docstring’leri açıklamalar ve örneklerle bir macros.yml (veya schema.yml) ile birleştirin.

Belgelendirme içeriği şunları içerebilir:

• Amaç ve beklenen çıktı (1–2 cümle)
• Varsayılanlar ve izin verilen değerlerle parametre tablosu
• Bir modelde ve run-operation ile çağrıma kısa örnek
• Veritabanları arası davranış notları

Bir yapılandırma dosyası için örnek parça:

version: 2
macros:
  - name: days_between
    description: |
      Return day difference between two date expressions, normalized across warehouses.
    arguments:
      - name: start_col
        type: string
        description: Column/expression for the start date
      - name: end_col
        type: string
        description: Column/expression for the end date
    docs:
      show: trueAltyapı:

3. Kod organizasyonu

Özellikle dizininizde çok sayıda makroyu yönetmeniz gerektiğinde, kodunuzun iyi organize edilmesi gerekir.

Kullanım kolaylığı için alanlara göre yapılandırmayı deneyin. İşte bunun bazı örnekleri:

• macros/date_utils.sql
• macros/string_utils.sql
• macros/testing/ (özel testler)
• macros/admin/ (DDL, bakım işleri)
• macros/compat/ (ambar uyarlamaları)

4. Makroları küçük ve tek amaçlı tutun

Bir makro tek bir işi iyi yapmalıdır. Bir makronun çok büyüdüğünü veya ilgisiz mantıkları ele aldığını fark ederseniz, onu daha küçük makrolara bölün. Bu, yeniden kullanılabilirliği artırır ve test etmeyi kolaylaştırır.

5. Makroları temsil edici verilerle test edin

Makro davranışını doğrulamak için özel test modelleri veya bir hazırlık ortamı kullanın. 

Örneğin:

• Köşe durumları kapsayan küçük bir tohum veri kümesi oluşturun.
• Makroyu farklı parametrelerle çağıran bir test modeli yazın.
• dbt run kullanın ve derlenen SQL’i doğruluk açısından inceleyin.

İpucu: Çıktıların beklenen kısıtları karşıladığını doğrulamak için makroları dbt test özel testleriyle eşleştirin.

Yaygın Kullanım Alanları ve Uygulamalar

dbt makroları çok yönlüdür ve uygulamaları, günlük analitik mühendisliği iş akışlarının çoğuna uzanır. 

İşte genişletilmiş, ayrıntılı bazı örnekler:

• Veri dönüşümlerini standartlaştırma: Makrolar, birden fazla modele aynı adlandırma kurallarının, kırpmanın, null yönetiminin ve tür dönüştürme mantığının uygulanmasını sağlayabilir. Örneğin, tüm martlarda isimleri aynı şekilde temizlemek ve biçimlendirmek için bir standardize_customer_name makrosu oluşturabilirsiniz.
• Veritabanları arası sorguları destekleme: Ambarların SQL lehçelerinde ince farklılıklar vardır. Makrolar bu farklılıkları soyutlayabilir—Snowflake’te DATEDIFF, BigQuery’de DATE_DIFF kullanmak gibi. Bu, modellerinizi taşınabilir kılar.
• Kalite kontrollerini otomatikleştirme: Yinelenen ID’leri, kritik sütunlarda null değerleri veya aralık dışı değerleri kontrol eden veri testlerini üreten yeniden kullanılabilir makrolar yazın. Bunlar birden çok test modelinde çağrılabilir.
• Tekrarlayan SQL kalıplarını basitleştirme: Yaygın CTE’ler, hesaplanan alanlar veya filtreleme koşulları makrolarda parametreleştirilebilir. Örneğin, isteğe bağlı filtrelere dayalı dinamik WHERE ifadeleri oluşturan bir makro, karmaşık mantığı kopyalayıp yapıştırmayı önler.

İleri Düzey Teknikler ve Performans Optimizasyonu

dbt makroları daha gelişmiş uygulamalarda da kullanılabilir. Aşağıda iki yaygın yönteme bakalım.

Özyinelemeli ve meta-programlama desenleri

Makrolar diğer makroları çağırabilir, meta veriler üzerinde döngü kurabilir veya şema incelemesine dayalı olarak SQL parçalarını dinamik olarak üretebilir. 

Bu sayede şunları yapabilirsiniz:

• Her kaynak tablo için otomatik olarak hazırlık (staging) modelleri oluşturmak.
• Her sütunu elle yazmadan pivot/unpivot sorguları oluşturmak.
• Yapılandırma değişkenleri üzerinde döngü kurarak ortama duyarlı sorgular inşa etmek.

Performans optimizasyon stratejileri

Performansı artırmak için ayrıca şu optimizasyonları uygulayabilirsiniz:

• Sadece gerekli sütunları veya join’leri seçerek sorgu karmaşıklığını en aza indirin.
• Ambar türüne göre malzemeleştirmeleri veya SQL stratejilerini ayarlayın.

dbt Ekosistemiyle Entegrasyon

Makrolar, dbt ekosisteminin bir parçası olacak şekilde oluşturulmuştur; paketler, bulut özellikleri ve harici araçlarla eşleştirildiğinde daha da güçlü hale gelirler.

Paket yönetimi

Topluluk paketlerinin çoğu—dbt-utils, dbt-date ve dbt-expectations gibi—özünde yüksek oranda yeniden kullanılabilir makro koleksiyonlarıdır. 

Bu paketler, tekerleği yeniden icat etmeden hazır dönüşümler, testler ve yardımcılar sunar. 

dbt Cloud ve geliştirici araçlarıyla uyumluluk

Makrolar, dbt Cloud ortamlarında sorunsuz çalışır; yani dinamik SQL mantığınız yerelde veya zamanlanmış bir bulut işinde çalıştırıldığında aynı şekilde davranır. 

Ayrıca sürüm kontrolü, CI/CD ardışık düzenleri ve kod inceleme süreçleriyle iyi entegre olurlar; böylece makro güncellemeleri tutarlı şekilde test edilip dağıtılır.

Gerçek Dünya Uygulama Stratejileri

Geleneksel SQL betiklerinden makro odaklı bir dbt iş akışına geçiş, hem teknik değişiklikler hem de kültürel benimseme gerektirir.

Geçiş ve değişim yönetimi

Geçiş yaparken, önce modeller arasında tekrarlanan SQL kalıplarını belirleyin. Ardından bunları kademeli olarak makrolara yeniden düzenleyin ve derlenen SQL’in eski mantıkla eşleştiğini doğrulayın. 

Yayına alım sırasında kesintiyi en aza indirmek için yeni makro mantığını açıp kapatmak amacıyla özellik bayraklarını (var()) kullanın. En önemlisi, alt sorguları bozmayı önlemek için paydaşlarınızı değişikliklerden haberdar edin.

Yönetişim ve dağıtım stratejileri

Yönetişim için, tüm makrolar için net adlandırma kuralları, parametre standartları ve belgelendirme gereklilikleri belirleyerek başlayın.

Sonra, performans ve uyumluluk standartlarını karşıladıklarından emin olmak için makro değişikliklerini model güncellemeleri gibi çekme isteklerinde gözden geçirin. 

Prod ortamında, beklendiği gibi çalıştıklarını doğrulamak için makro tarafından üretilen sorgulara ilişkin iş günlüklerini izleyin. Makro ağırlıklı projelerde, derleme sürelerini ve makro türüne göre sorgu performansını izlemek için gözlemlenebilirlik panoları kurun.

Sonuç

dbt makroları, modern analitik mühendisliği ekiplerinde üretkenlik ve sürdürülebilirliğin kilit bir parçasıdır. dbt modellerini makrolarla birlikte kullanmak, veri temizleme işlemleri için daha iyi sonuçlar doğurabilir.

dbt hakkında daha fazla bilgi almak ister misiniz? Introduction to dbt kursumuz ve dbt Tutorial içeriğimiz size yardımcı olabilir.