dbt मैक्रोज़: एक व्यापक मार्गदर्शिका

एनालिटिक्स इंजीनियरिंग में, dbt (data build tool) मैक्रो डायनेमिक, पुन: प्रयोज्य SQL लॉजिक लिखने का एक शक्तिशाली तरीका प्रदान करते हैं, जो पुन: प्रयोज्य कोड ब्लॉक्स के रूप में होते हैं। 

इस ट्यूटोरियल में, हम dbt मैक्रोज़ की बुनियादी बातें, उन्हें Jinja से कैसे बनाना है, बेहतर अनुरक्षण के लिए सर्वोत्तम अभ्यास, और वास्तविक उपयोग—सब कुछ कोड उदाहरणों के साथ—का अन्वेषण करेंगे। 

dbt मैक्रोज़ क्या हैं?

dbt मैक्रोज़ Jinja टेंप्लेटिंग भाषा का उपयोग करके dbt के भीतर लिखे गए पुन: प्रयोज्य कोड ब्लॉक हैं, जो आपको SQL को डायनेमिक रूप से जनरेट करने देते हैं। ये पुनरावृत्ति घटाते हैं और ट्रांसफॉर्मेशन लॉजिक को केन्द्रीकृत करते हैं। 

ये मैक्रो पारंपरिक प्रोग्रामिंग भाषाओं में फंक्शनों की तरह ही काम करते हैं।

उदाहरण के लिए, यदि आपको कई मॉडलों में किसी विशिष्ट मीट्रिक की गणना करनी हो, तो एक मैक्रो उस गणना को समाहित कर सकता है, जिससे उसे बनाए रखना और अपडेट करना आसान हो जाता है।

मैक्रोज़ पैकेजों में भी संग्रहीत किए जा सकते हैं, जैसे dbt-utils।

dbt मैक्रोज़ का उपयोग क्यों करें?

मैक्रोज़ कई फायदे लाते हैं, मुख्यतः:

• अतिरिक्तता में कमी: आप एक लॉजिक ब्लॉक एक बार लिखकर हर जगह पुन: उपयोग कर सकते हैं।
• संगतता: बिना मैनुअल डुप्लिकेशन के एक जैसी ट्रांसफॉर्मेशन लॉजिक को मॉडलों में लागू करना।
• लचीलापन: मैक्रोज़ पैरामीटर सपोर्ट करते हैं, जिससे वे विभिन्न इनपुट्स के अनुरूप ढल जाते हैं।
• क्रॉस-प्रोजेक्ट शेयरिंग: अच्छी तरह डिज़ाइन किए गए मैक्रोज़ को पैकेज के रूप में साझा किया जा सकता है।

इन लाभों से कोडबेस अधिक साफ, अनुरक्षित और स्केलेबल बनते हैं।

dbt मैक्रो के मौलिक सिद्धांत

यह समझने में आपकी मदद के लिए कि dbt में मैक्रोज़ कैसे काम करते हैं, आइए कुछ प्रमुख अवधारणाएँ देखें।

1. पुन: प्रयोज्यता

मैक्रो आपको SQL लॉजिक का एक हिस्सा एक बार परिभाषित करने और उसे कई मॉडलों, परीक्षणों, या अन्य मैक्रोज़ में भी पुन: उपयोग करने देते हैं।

2. Jinja टेंप्लेटिंग इंजन

Jinja का dbt के साथ एकीकरण आपको वेरिएबल जोड़ने, कंडीशंस लागू करने और सूचियों पर लूप चलाने की सुविधा देता है—यह सब आपके SQL के डेटाबेस तक पहुँचने से पहले। dbt इस टेम्पलेट को रॉ SQL में कंपाइल करता है, जिससे मैक्रोज़ डेटाबेस-अज्ञेय बनते हैं।

3. प्रोग्रामिंग तकनीकों का समावेश

मैक्रोज़ SQL को एक प्रोग्रामेबल फ्रेमवर्क में बदल सकते हैं। वे लॉजिक, लूप्स और कंडीशंस की अनुमति देते हैं—ऐसी आम बातें जिन्हें मानक SQL उतनी लचीलेपन से नहीं संभाल पाता।

फंक्शनों की तरह, dbt में मैक्रो आर्ग्युमेंट्स (पैरामीटर्स) स्वीकार कर सकते हैं और अलग-अलग इनपुट्स के साथ कॉल किए जा सकते हैं ताकि अलग-अलग आउटपुट मिलें। वे जटिल ट्रांसफॉर्मेशंस को छोटे, पुन: प्रयोज्य यूनिट्स में बाँटकर सरल बनाते हैं। 

Jinja से मैक्रो बनाना

अब, देखते हैं कि हम अपने लिए कुछ मैक्रोज़ कैसे बना सकते हैं।

Jinja वह टेंप्लेटिंग इंजन है जो dbt मैक्रोज़ को शक्ति देता है, जिससे आप SQL को डायनेमिक, प्रोग्रामेबल टेक्स्ट की तरह ट्रीट कर सकते हैं। 

टेम्पलेट कॉनस्ट्रक्ट और डिलिमिटर्स

Jinja का उपयोग करने के लिए, आपको विशेष टेम्पलेट कॉनस्ट्रक्ट और डिलिमिटर्स का उपयोग करना होगा।

यहाँ कुछ सामान्य कॉनस्ट्रक्ट और डिलिमिटर्स हैं:

• एक्सप्रेशंस {{ }}: अभिव्यक्तियाँ सम्मिलित करता है।
• स्टेटमेंट्स {% %}: स्टेटमेंट्स निष्पादित करता है।
• कमेंट्स {# #}: ऐसे कमेंट जोड़ता है जिन्हें आप dbt से अनदेखा कराना चाहते हैं।

मैक्रोज़ में, {{ ... }} का उपयोग उन अभिव्यक्तियों के लिए होता है जिन्हें कोई वैल्यू आउटपुट करनी चाहिए (जैसे, कॉलम नाम या कैलकुलेशन), जबकि {% ... %} का उपयोग कंट्रोल फ्लो (लूप्स, if/else स्टेटमेंट्स, मैक्रो डेफिनिशन) के लिए किया जाता है। Jinja कमेंट्स {# ... #} का उपयोग करते हैं और कंपाइलेशन के दौरान पूरी तरह हटा दिए जाते हैं।

यहाँ मैक्रोज़ में उपयोग किए जाने वाले स्टेटमेंट्स के लिए प्रयुक्त सिंटैक्स का एक नमूना है:

{% macro your_macro_name(your_variable) %}
    select 'Hello, {{ your_variable}}' as greeting
{% endmacro %}संचालित द्वारा

यहाँ स्टेटमेंट्स का उपयोग करके मैक्रो बनाने का एक उदाहरण है:

{% macro greet(name) %}
    select 'Hello, {{ name }}' as greeting
{% endmacro %}संचालित द्वारा

मैक्रो चलाने के लिए, इसका उपयोग करें:

dbt run-operation greet(name) --args 'Austin'संचालित द्वारा

वेरिएबल प्रबंधन

आप मैक्रोज़ में वेरिएबल पास कर सकते हैं या भीतर ही परिभाषित कर सकते हैं। upper या lower जैसे फ़िल्टर टेक्स्ट वैल्यूज़ को ट्रांसफॉर्म कर सकते हैं।

यहाँ सभी टेक्स्ट वैल्यूज़ को अपरकेस में बदलने के लिए upper फ़ंक्शन का इम्प्लीमेंटेशन है। 

{% macro to_upper_case(column_name) %}
    upper({{ column_name }})
{% endmacro %}संचालित द्वारा

इसे लागू करने के लिए, आपको अपने dbt मॉडल में नए बनाए गए मैक्रो को कॉल/रेफरेंस करना होगा।

यहाँ एक कोड उदाहरण है:

SELECT
    id,
    {{ to_upper_case('product_name') }} AS product_name_upper
FROM {{ source('public', 'orders') }}संचालित द्वारा

कंट्रोल स्ट्रक्चर्स

अगला, प्रोग्रामिंग भाषाओं की तरह, dbt मैक्रो निम्नलिखित प्रदान कर सकते हैं:

• कंडीशनल स्टेटमेंट्स ({% if %} / {% endif %}):
• लूप्स ({% for %} / {% endfor %}) 

ये स्ट्रक्चर आपको इनपुट्स के आधार पर डायनेमिक रूप से SQL क्लॉज़ बनाने या कई अभिव्यक्तियाँ जनरेट करने देते हैं।

इससे मैक्रोज़ के लिए जटिल SQL जेनरेशन कार्यों को संभालना आसान हो जाता है।

पैरामीटर हैंडलिंग और एरर मैनेजमेंट

मैक्रोज़ इनपुट्स को वैलिडेट कर सकते हैं और रनटाइम समस्याओं को रोकने के लिए कंपाइल टाइम पर एरर उठा सकते हैं।

पैरामीटर मैक्रो डिक्लेरेशन के भीतर () पेरेंथेसिस का उपयोग करके परिभाषित किए जाते हैं, जो प्रोग्रामिंग भाषाओं में फ़ंक्शन परिभाषाओं के समान है।

यहाँ हम 2 पैरामीटर्स कैसे शामिल कर सकते हैं, इसका उदाहरण है:

{% macro my_macro(param1, param2) %}
    SELECT
        {{ param1 }},
        {{ param2 }}
    FROM my_table
{% endmacro %}संचालित द्वारा

जैसा कि आप देख सकते हैं, पहली पंक्ति में हमने param1 और param2 दोनों शामिल किए हैं।

dbt मॉडल में मैक्रो को कॉल करने के लिए, आपको डबल कर्ली ब्रेसेस {{ }} का उपयोग करना चाहिए। पैरामीटर्स पेरेंथेसिस के भीतर आर्ग्युमेंट्स के रूप में पास किए जाते हैं।

SELECT
    id,
    {{ my_macro('column_a', 'column_b') }}
FROM my_source_tableसंचालित द्वारा

इस मामले में, हमने column_a और column_b दोनों को अपने पैरामीटर के रूप में निर्दिष्ट किया है।

dbt मैक्रोज़ के साथ काम करने के लिए सेटअप गाइड

मैक्रोज़ बनाना और उपयोग करना शुरू करने से पहले, आइए एक वर्किंग एनवायरनमेंट सेट करें ताकि आप इस ट्यूटोरियल के उदाहरणों के साथ फॉलो कर सकें। 

इससे सुनिश्चित होगा कि आपके पास dbt इंस्टॉल है, एक सैंपल डेटासेट लोड है, और मैक्रोज़ बनाने के लिए सही फ़ोल्डर संरचना है।

1. dbt Core इंस्टॉल करें

आपको लोकली dbt Core इंस्टॉल होना चाहिए। यदि आप इस ट्यूटोरियल में Postgres का उपयोग कर रहे हैं, तो यह कमांड चलाएँ:

pip install dbtसंचालित द्वारा

यदि आपका प्रोजेक्ट किसी डेटा वेयरहाउस का उपयोग करता है, तो इसके बजाय संबंधित कमांड चलाएँ:

pip install dbt-core dbt-postgres

pip install dbt-core dbt-snowflake

pip install dbt-core dbt-bigqueryसंचालित द्वारा

2. एक dbt प्रोजेक्ट बनाएं

कोई भी dbt कमांड चलाने से पहले, हमें एक प्रोजेक्ट एनवायरनमेंट सेट करना होगा।

अपने इच्छित प्रोजेक्ट्स डायरेक्टरी पर जाएँ।

यहीं आप अपने dbt प्रोजेक्ट फाइल्स स्टोर करेंगे। इस मामले में, हम इस dbt प्रोजेक्ट फ़ोल्डर में सभी संबंधित फाइल्स स्टोर करेंगे।

एक dbt प्रोजेक्ट इनिशियलाइज़ करने के लिए, आपको यह चलाना होगा:

dbt initसंचालित द्वारा

cd ~/dbt-macros-tutorialसंचालित द्वारा

इस फ़ॉर्मेट में एक फ़ोल्डर संरचना बनाएं:

macros_tutorial/
  ├─ models/
  ├─ macros/
  ├─ tests/
  ├─ seeds/
  ├─ dbt_project.ymlसंचालित द्वारा

3. सैंपल डेटासेट तैयार करें

हम Python का उपयोग करके एक छोटा ऑर्डर्स डेटासेट जनरेट करेंगे और उसे Postgres (या आपके चुने हुए वेयरहाउस) में लोड करेंगे।

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)संचालित द्वारा

नोट: अपने डेटाबेस के लिए कनेक्शन स्ट्रिंग अपडेट करें।

4. dbt में एक स्रोत बनाएं

निम्नलिखित को models/src_orders.yml में जोड़ें:

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

    tables:
      - name: ordersसंचालित द्वारा

5. कनेक्शन और स्रोत का परीक्षण करें

dbt debug

dbt run-operation list_relations --args '{"schema_name": "public"}'संचालित द्वारा

अब आप इस डेटासेट पर ऑपरेट करने वाले मैक्रोज़ लिखना शुरू करने के लिए तैयार हैं।

dbt मैक्रोज़ कैसे लिखें और उपयोग करें

अब, आइए अपने कुछ मैक्रोज़ लिखकर देखें।

मैक्रोज़ परिभाषित करना

मैक्रो डेफिनिशन को macros/ डायरेक्टरी के अंतर्गत .sql फाइलों में रखें।

मैक्रोज़ का नामकरण करते समय, सुनिश्चित करें कि हर मैक्रो को उसके उद्देश्य को दर्शाने वाला वर्णनात्मक नाम दें, और उन्हें लचीला बनाने के लिए पैरामीटर्स का उपयोग करें। ऊपर एक संक्षिप्त डॉकस्ट्रिंग कमेंट जोड़ना टीम के साथियों को इसके इरादे को समझने में मदद करता है।

यहाँ एक उदाहरण है:

    -- macros/my_macro.sql
    {% macro cents_to_dollars(column_name, precision=2) %}
        ({{ column_name }} / 100.0)::numeric(18, {{ precision }})
    {% endmacro %}संचालित द्वारा

मॉडलों में मैक्रोज़ को कॉल करना

आप मॉडलों के भीतर {{ macro_name(arg1, arg2) }} के साथ मैक्रोज़ को कॉल करते हैं। इन्हें SELECT क्लॉज़, WHERE फ़िल्टर्स, या पूरे CTE ब्लॉक्स में भी उपयोग किया जा सकता है, जिससे आप कहीं भी पुन: प्रयोज्य SQL पैटर्न इंजेक्ट कर सकें।

यहाँ एक उदाहरण है:

    -- 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') }}संचालित द्वारा

CLI से मैक्रोज़ को कॉल करना

मॉडल बिल्ड्स के बाहर ऑपरेशनल टास्क के लिए, इस फ़ॉर्मेट/सिंटैक्स का उपयोग करें:

dbt run-operation macro_name --args '{"param": "value"}'संचालित द्वारा

यह आपको स्कीमा क्रिएशन या डेटा क्लीनअप जैसी यूटिलिटी SQL चलाने देता है, बिना कोई मॉडल बिल्ड किए।

यहाँ एक कमांड उदाहरण है:

dbt run-operation greet --args '{"name": "Austin"}'संचालित द्वारा

पैकेजों से मैक्रोज़ का उपयोग

मैक्रोज़ dbt में पैकेजों से भी आ सकते हैं, जैसे dbt-utils।

जब आप packages.yml के माध्यम से कोई पैकेज इंस्टॉल करते हैं, तो उसके मैक्रोज़ तुरंत उपलब्ध हो जाते हैं। ऐसा करने के लिए, आपको dbt deps चलाना होगा।

फिर आप इस फ़ॉर्मेट से नए जोड़े गए मैक्रोज़ को कॉल कर सकते हैं: package_name.macro_name।

मैक्रो फाइल संगठन

बेहतर संगठन के लिए, मैक्रोज़ को फंक्शनैलिटी के आधार पर क्रमबद्ध और अलग करें ताकि अनुरक्षण में सुधार हो। 

सम्बंधित मैक्रोज़ को अलग-अलग फाइलों में ग्रुप करने का प्रयास करें (उदा., date_utils.sql, string_utils.sql) ताकि अनुरक्षणीयता बनी रहे। इससे समय के साथ लॉजिक को ढूँढना और अपडेट करना आसान हो जाता है।

व्यवहार में dbt मैक्रोज़ के उदाहरण

यहाँ अधिक व्यावहारिक उपयोग मामलों में मैक्रोज़ के कुछ उदाहरण हैं:

तिथि तुलना मैक्रो

मान लें कि आप एक ऐसा फ़ंक्शन बनाना चाहते हैं जिसका उपयोग आप अक्सर तिथियों की तुलना करने के लिए करेंगे।

इस मामले में, आप दो दिनांक फ़ील्ड्स के बीच दिनों के अंतर की गणना करने के लिए, साथ ही SQL डायलैक्ट के अंतर को संभालते हुए, मैक्रो का उपयोग कर सकते हैं।

यहाँ एक नई फाइल बनाकर शुरू करें: macros/date_utils.sql।

इसके बाद, निम्नलिखित कोड का उपयोग करें:

{% 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 %}संचालित द्वारा

अब, हम इस नए days_between मैक्रो का एक मॉडल में उपयोग करेंगे।

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 srcसंचालित द्वारा

कस्टमाइज़्ड generate_schema_name मैक्रो

डिफ़ॉल्ट रूप से, dbt generate_schema_name नामक एक डिफ़ॉल्ट मैक्रो का उपयोग करता है। यह मैक्रो उस स्कीमा का नाम निर्दिष्ट करने के लिए उपयोग होता है जिसमें कोई मॉडल बनाया जाना चाहिए।

आप प्रति एनवायरनमेंट उपयोग होने वाले स्कीमा को नियंत्रित करने के लिए dbt के डिफ़ॉल्ट को ओवरराइड भी कर सकते हैं।

आप इस फाइल को यहाँ शामिल कर सकते हैं: 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 %}संचालित द्वारा

कैसे मदद करता है: dev पर, मॉडल्स dev_analytics (आइसोलेशन) एनवायरनमेंट में लैंड करते हैं। prod पर, वे analytics में लैंड करते हैं। इससे पूर्वानुमेय, टकराव-मुक्त डिप्लॉयमेंट्स बनते हैं।

मॉडल के बाहर SQL निष्पादित करना

आप मॉडल्स के बाहर भी टेबल क्लीनअप या मेटाडेटा अपडेट जैसी ऑपरेशंस के लिए SQL कमांड चला सकते हैं, बिना मॉडल बनाए।

आप एक मैक्रो लिख सकते हैं जो रॉ SQL निष्पादित करता है और फिर उसे dbt run-operation के माध्यम से चला सकते हैं।

यह DDL (टेबल्स ड्रॉप/क्रिएट) या ऐसे मेटाडेटा अपडेट के लिए उपयोगी है जो किसी मॉडल में फिट नहीं होते।

यहाँ मैक्रो है:

{% 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 %}संचालित द्वारा

इसके बाद, टर्मिनल में यह ऑपरेशन चलाएँ:

dbt run-operation cleanup_temp_tablesसंचालित द्वारा

यह आपको मॉडल्स के भीतर शामिल किए बिना मैक्रोज़ चलाने की अनुमति देगा।

पैरामीटराइज़्ड मैक्रो उदाहरण

हम एक ऐसा मैक्रो भी बना सकते हैं जो फ़ंक्शन की तरह अत्यधिक पैरामीटराइज़्ड हो। 

इस उदाहरण में, हम दिए गए स्टेटस के आधार पर रिकॉर्ड्स को फ़िल्टर करेंगे, जो तब लागू होगा जब वैल्यूज़ प्रदान की जाएँ। यह लॉजिक बनाने के लिए if और do स्टेटमेंट्स का उपयोग करता है।

{% 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 %}संचालित द्वारा

अब हम इस मैक्रो को एक मॉडल में लागू करते हैं:

with src as (
  select * from {{ ref('orders') }}
)
select *
from src
{{ where_orders(status='shipped', min_date='2025-01-05') }}संचालित द्वारा

यह मैक्रो उस स्थिति के लिए लॉजिक बनाता है जब कोई आर्ग्युमेंट छोड़ा जाए; तब वह मानदंड अनदेखा हो जाता है। इससे वैकल्पिक लॉजिक सुव्यवस्थित रहता है।

dbt मैक्रोज़ के लिए सर्वोत्तम अभ्यास

बेहतरीन मैक्रोज़ डिज़ाइन करना केवल SQL को कंपाइल करा देने से आगे की बात है। सर्वश्रेष्ठ मैक्रोज़ खोजने में आसान, अच्छी तरह प्रलेखित, पूर्वानुमेय, परीक्षणयोग्य होते हैं और उन्हें डिप्रिकेट या एक्सटेंड करना आसान होता है। 

ये कुछ सर्वोत्तम अभ्यास हैं जिनका पालन करें:

1. नामकरण मानक और पैरामीटर डिज़ाइन

SQL और प्रोग्रामिंग भाषाओं की तरह, पठनीयता सुनिश्चित करने के लिए नामकरण मानकों का पालन किया जाना चाहिए।

यहाँ कुछ नामकरण सुझाव हैं:

• स्पष्ट और क्रिया-उन्मुख रहें। अस्पष्ट नामों helper की बजाय क्रियाएँ या स्पष्ट इरादे चुनें (जैसे, generate_select_list, where_orders)।
• नाम स्थिर और लोअरकेस रखें। snake_case और डोमेन-आधारित स्थिर प्रीफ़िक्स का उपयोग करें, जैसे date_*, string_*, test_*, admin_*।

2. प्रलेखन रणनीतियाँ

आपको जो बनाते हैं उसे डॉक्युमेंट करने की आदतें विकसित करनी चाहिए। डॉक्युमेंटेशन वहीं करें जहाँ डेवलपर्स देखते हैं। 

उदाहरण के लिए, इनलाइन डॉकस्ट्रिंग्स + macros.yml (या schema.yml) को विवरणों और उदाहरणों के साथ संयोजित करें।

डॉक्युमेंटेशन सामग्री में शामिल हो सकते हैं:

• उद्देश्य और अपेक्षित आउटपुट (1–2 वाक्य)
• पैरामीटर तालिका, डिफ़ॉल्ट और स्वीकृत मानों के साथ
• मॉडल में और run-operation के साथ आह्वान का छोटा उदाहरण
• क्रॉस-डेटाबेस व्यवहार संबंधी नोट्स

कॉनफिग फाइल का उदाहरण स्निपेट:

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: trueसंचालित द्वारा

3. कोड संगठन

आपका कोड भी अच्छी तरह संगठित होना चाहिए, खासकर जब आपको अपनी डायरेक्टरी में बड़ी संख्या में मैक्रोज़ प्रबंधित करने हों।

उपयोग में आसानी के लिए डोमेन के अनुसार संरचना बनाने की कोशिश करें। इसके कुछ उदाहरण:

• macros/date_utils.sql
• macros/string_utils.sql
• macros/testing/ (कस्टम टेस्ट)
• macros/admin/ (DDL, हाउसकीपिंग)
• macros/compat/ (वेयरहाउस शिम्स)

4. मैक्रोज़ को छोटा और सिंगल-पर्पस रखें

एक मैक्रो को एक काम अच्छे से करना चाहिए। यदि कोई मैक्रो बहुत बड़ा हो रहा है या असंबंधित लॉजिक संभाल रहा है, तो उसे छोटे मैक्रोज़ में बाँट दें। इससे पुन: प्रयोज्यता बढ़ती है और परीक्षण सरल होता है।

5. प्रतिनिधि डेटा के साथ मैक्रोज़ का परीक्षण करें

मैक्रो व्यवहार को वैलिडेट करने के लिए समर्पित टेस्ट मॉडल्स या स्टेजिंग एनवायरनमेंट का उपयोग करें। 

उदाहरण के लिए:

• ऐसा छोटा सीड डेटासेट बनाएं जो एज केस कवर करे।
• ऐसा टेस्ट मॉडल लिखें जो अलग-अलग पैरामीटर्स के साथ मैक्रो को कॉल करे।
• dbt run का उपयोग करें और सही होने के लिए कंपाइल्ड SQL का निरीक्षण करें।

प्रो टिप: आउटपुट अपेक्षित बाधाओं को पूरा करते हैं या नहीं, इसकी जाँच के लिए मैक्रोज़ को dbt test कस्टम टेस्ट के साथ पेयर करें।

सामान्य उपयोग के मामले और अनुप्रयोग

dbt मैक्रोज़ बहुमुखी हैं, और उनके अनुप्रयोग रोज़मर्रा के एनालिटिक्स इंजीनियरिंग वर्कफ़्लो में व्यापक रूप से फैलते हैं। 

यहाँ कुछ विस्तृत, विस्तारित उदाहरण हैं:

• डेटा ट्रांसफॉर्मेशन का मानकीकरण: मैक्रोज़ यह सुनिश्चित कर सकते हैं कि एक जैसे नेमिंग कन्वेंशन, ट्रिमिंग, null-हैंडलिंग, और टाइप-कास्टिंग लॉजिक कई मॉडलों पर लागू हों। उदाहरण के लिए, आप standardize_customer_name मैक्रो बना सकते हैं, जो सभी मार्ट्स में नामों को एक समान तरीके से साफ और फ़ॉर्मैट करे।
• क्रॉस-डेटाबेस क्वेरी सपोर्ट करना: वेयरहाउस में सूक्ष्म SQL डायलैक्ट अंतर होते हैं। मैक्रोज़ इन अंतरों को एब्स्ट्रैक्ट कर सकते हैं—जैसे Snowflake पर DATEDIFF और BigQuery पर DATE_DIFF का उपयोग। इससे आपके मॉडल्स पोर्टेबल हो जाते हैं।
• क्वालिटी चेक का स्वचालन: पुन: प्रयोज्य मैक्रोज़ लिखें जो डेटा टेस्ट जनरेट करें, जैसे डुप्लिकेट IDs की जाँच, क्रिटिकल कॉलम्स में nulls, या रेंज से बाहर के मान। इन्हें कई टेस्ट मॉडलों में आह्वान किया जा सकता है।
• दोहरावदार SQL पैटर्न को सरल बनाना: सामान्य CTEs, कैलकुलेटेड फ़ील्ड्स, या फ़िल्टरिंग क्लॉज़ मैक्रोज़ में पैरामीटराइज़ किए जा सकते हैं। उदाहरण के लिए, वैकल्पिक फ़िल्टर्स के आधार पर डायनेमिक WHERE क्लॉज़ बनाने के लिए मैक्रो जटिल लॉजिक कॉपी-पेस्ट करने से बचाता है।

उन्नत तकनीकें और प्रदर्शन अनुकूलन

dbt मैक्रोज़ का उपयोग अधिक उन्नत अनुप्रयोगों में भी किया जा सकता है। आइए नीचे दो सामान्य तरीकों पर नज़र डालें।

रिकर्सिव और मेटा-प्रोग्रामिंग पैटर्न

मैक्रोज़ अन्य मैक्रोज़ को कॉल कर सकते हैं, मेटाडेटा पर लूप चला सकते हैं, या स्कीमा इंस्पेक्शन के आधार पर डायनेमिक रूप से SQL फ्रैगमेंट जनरेट कर सकते हैं। 

यह आपको सक्षम बनाता है:

• हर स्रोत टेबल के लिए स्वतः स्टेजिंग मॉडल बनाना।
• प्रत्येक कॉलम को मैन्युअली टाइप किए बिना पिवट/अनपिवट क्वेरियाँ जनरेट करना।
• कॉनफिग वेरिएबल्स पर लूप चलाकर एनवायरनमेंट-अवेयर क्वेरियाँ बनाना।

प्रदर्शन अनुकूलन रणनीतियाँ

आप प्रदर्शन बढ़ाने के लिए आगे का अनुकूलन भी कर सकते हैं:

• केवल आवश्यक कॉलम्स या जोइन्स को चयनित रूप से शामिल करके क्वेरी जटिलता को न्यूनतम करें।
• वेयरहाउस प्रकार के आधार पर मटेरियलाइज़ेशन या SQL रणनीतियाँ समायोजित करें।

dbt इकोसिस्टम के साथ एकीकरण

मैक्रोज़ dbt इकोसिस्टम का हिस्सा बनने के लिए बनाए गए हैं, और पैकेज, क्लाउड फीचर्स और बाहरी टूल्स के साथ मिलकर वे और भी शक्तिशाली हो जाते हैं।

पैकेज प्रबंधन

कई कम्युनिटी dbt पैकेज, जैसे dbt-utils, dbt-date, और dbt-expectations, मूलतः अत्यधिक पुन: प्रयोज्य मैक्रोज़ के संग्रह हैं। 

ये पैकेज बिना पहिया फिर से आविष्कार किए प्रीबिल्ट ट्रांसफॉर्मेशंस, टेस्ट्स और हेल्पर्स लाते हैं। 

dbt Cloud और डेवलपर टूल्स के साथ संगतता

मैक्रोज़ dbt Cloud एनवायरनमेंट्स में सहजता से काम करते हैं, यानी आपका डायनेमिक SQL लॉजिक लोकली चलाने पर या एक शेड्यूल्ड क्लाउड जॉब में—दोनों में समान व्यवहार करता है। 

ये वर्ज़न कंट्रोल, CI/CD पाइपलाइंस और कोड रिव्यू प्रक्रियाओं के साथ भी अच्छी तरह एकीकृत होते हैं, यह सुनिश्चित करते हुए कि मैक्रो अपडेट्स लगातार टेस्ट और डिप्लॉय हों।

वास्तविक दुनिया में कार्यान्वयन रणनीतियाँ

पारंपरिक SQL स्क्रिप्ट्स से मैक्रो-चालित dbt वर्कफ़्लो पर जाने के लिए तकनीकी बदलावों और सांस्कृतिक अपनाने—दोनों—की आवश्यकता होती है।

माइग्रेशन और चेंज मैनेजमेंट

माइग्रेट करते समय, मॉडलों में दोहराए जाने वाले SQL पैटर्न की पहचान से शुरुआत करें। फिर इन्हें क्रमिक रूप से मैक्रोज़ में रिफैक्टर करें, यह वैलिडेट करते हुए कि कंपाइल्ड SQL पुरानी लॉजिक से मेल खाता है। 

रोलआउट के दौरान व्यवधान कम करने के लिए नए मैक्रो लॉजिक को ऑन/ऑफ टॉगल करने हेतु फीचर फ्लैग्स (var()) का उपयोग करें। सबसे महत्वपूर्ण, आपको अपने स्टेकहोल्डर्स को परिवर्तनों की सूचना देनी चाहिए ताकि डाउनस्ट्रीम क्वेरियाँ न टूटें।

गवर्नेंस और डिप्लॉयमेंट रणनीतियाँ

गवर्नेंस के लिए, सभी मैक्रोज़ हेतु स्पष्ट नामकरण मानक, पैरामीटर स्टैंडर्ड्स और डॉक्युमेंटेशन आवश्यकताओं की स्थापना से शुरुआत करें।

इसके बाद, मैक्रो परिवर्तनों की समीक्षा पुल रिक्वेस्ट्स में ठीक उसी तरह करें जैसे मॉडल अपडेट्स की, यह सुनिश्चित करते हुए कि वे प्रदर्शन और अनुकूलता मानकों को पूरा करते हैं। 

प्रोडक्शन में, यह सत्यापित करने के लिए मैक्रो-जेनरेटेड क्वेरियों के लिए जॉब लॉग्स की निगरानी करें कि वे अपेक्षित रूप से चल रही हैं। मैक्रो-हेवी प्रोजेक्ट्स के लिए, मैक्रो प्रकार के अनुसार कंपाइल टाइम्स और क्वेरी प्रदर्शन को ट्रैक करने हेतु ऑब्ज़र्वेबिलिटी डैशबोर्ड सेट करें।

निष्कर्ष

आधुनिक एनालिटिक्स इंजीनियरिंग टीमों में उत्पादकता और अनुरक्षणीयता का एक प्रमुख हिस्सा dbt मैक्रोज़ हैं। dbt मॉडलों के साथ मैक्रोज़ का उपयोग डेटा क्लीनिंग ऑपरेशंस के लिए बेहतर परिणाम दे सकता है।

dbt के बारे में और सीखना चाहते हैं? हमारा Introduction to dbt कोर्स और dbt ट्यूटोरियल आपके लिए सहायक हो सकते हैं।