Zuordnen von Kosten

Eine Organisation kann die Kosten für die Nutzung von Snowflake auf logische Einheiten innerhalb der Organisation umlegen (zum Beispiel auf verschiedene Abteilungen, Umgebungen oder Projekte). Dieses Chargeback- oder Showback-Modell ist für Buchhaltungszwecke nützlich und zeigt Bereiche der Organisation auf, die von Kontrollen und Optimierungen profitieren könnten, um die Kosten zu senken.

Um Kosten verschiedenen Gruppen wie Abteilungen oder Projekten zuzuordnen, verwenden Sie die folgende empfohlene Vorgehensweise:

  • Verwenden Sie Objekt-Tags, um Ressourcen und Benutzer mit Abteilungen oder Projekten zu verknüpfen.

  • Verwenden Sie Abfrage-Tags, um einzelne Abfragen mit Abteilungen oder Projekten zu verknüpfen, wenn die Abfragen von derselben Anwendung im Namen von Benutzern durchgeführt werden, die zu mehreren Abteilungen gehören.

Arten von Kostenzuordnungsszenarien

Die folgenden Kostenzuordnungsszenarien sind die am häufigsten anzutreffenden. In diesen Szenarien werden Warehouses als Beispiel für eine Ressource verwendet, die Kosten verursacht.

  • Ressourcen, die ausschließlich von einer einzigen Kostenstelle oder Abteilung verwendet werden: Ein Beispiel hierfür ist die Verwendung von Objekt-Tags, um Warehouses mit einer Abteilung zu verknüpfen. Sie können diese Objekt-Tags verwenden, um die Kosten, die für diese Warehouses anfallen, ausschließlich dieser Abteilung zuzuordnen.

  • Ressourcen, die von Benutzern aus mehreren Abteilungen gemeinsam genutzt werden: Ein Beispiel hierfür ist ein Warehouse, das von Benutzern aus verschiedenen Abteilungen gemeinsam genutzt wird. In diesem Fall verwenden Sie Objekt-Tags, um jeden Benutzer mit einer Abteilung zu verknüpfen. Die Kosten für Abfragen werden den Benutzern zugeordnet. Anhand der Objekt-Tags, die den Benutzern zugeordnet sind, können Sie die Kosten nach Abteilungen aufschlüsseln.

  • Anwendungen oder Arbeitsabläufe, die von Benutzern aus verschiedenen Abteilungen gemeinsam genutzt werden: Ein Beispiel hierfür ist eine Anwendung, die Abfragen im Namen ihrer Benutzer ausführt. In diesem Fall wird jeder Abfrage, die von der Anwendung ausgeführt wird, ein Abfrage-Tag zugewiesen, das das Team oder die Kostenstelle des Benutzers identifiziert, in dessen Namen die Abfrage durchgeführt wird.

In den nächsten Abschnitten erfahren Sie, wie Sie Objekt-Tags in Ihren Konten einrichten und welche Details Sie für jedes dieser Kostenzuordnungsszenarien benötigen.

Objekt-Tags für die Kostenzuordnung einrichten

Wenn Sie Tags für die Gruppierungen einrichten, die Sie für die Kostenzuordnung verwenden möchten, sollten Sie festlegen, ob die Gruppierungen für ein einzelnes Konto oder für mehrere Konten gelten. Dies bestimmt, wie Sie Ihre Tags einrichten.

Nehmen wir zum Beispiel an, dass Sie Kosten auf Grundlage der Abteilung zuordnen möchten.

  • Wenn sich die von der Abteilung verwendeten Ressourcen in einem einzigen Konto befinden, erstellen Sie die Tags in einer Datenbank in diesem Konto.

  • Wenn sich die von der Abteilung genutzten Ressourcen über mehrere Konten erstrecken, erstellen Sie die Tags in einem wichtigen Konto in Ihrer Organisation (z. B. in Ihrem Organisationskonto) und machen Sie diese Tags in anderen Konten durch Replikation verfügbar.

In den nächsten Abschnitten wird erklärt, wie Sie die Tags erstellen, die Tags replizieren und die Tags auf Ressourcen anwenden.

Bemerkung

Die Beispiele in diesen Abschnitten verwenden die kundenspezifische Rolle tag_admin, bei der davon ausgegangen wird, dass sie über die Berechtigungen zum Erstellen und Verwalten von Tags verfügt. Innerhalb Ihrer Organisation können Sie granularere Berechtigungen für das Taggen von Objekten verwenden, um eine sichere Tagging-Strategie zu entwickeln.

Tags erstellen

Entscheiden Sie sich bei der Entwicklung der Strategie für die Datenbank und das Schema, in dem Sie die Tags erstellen möchten.

  • Sie können eine eigene Datenbank und ein eigenes Schema für die Tags erstellen.

  • Wenn Sie Ressourcen in verschiedenen Konten in Ihrem Unternehmen mit Tags versehen möchten, können Sie die Tags in einem Schlüsselkonto in Ihrem Unternehmen erstellen (z. B. in Ihrem Organisationskonto).

Das folgende Beispiel erstellt eine Datenbank namens cost_management und ein Schema namens tags für die Tags, die Sie verwenden möchten:

USE ROLE tag_admin;

CREATE DATABASE cost_management;
CREATE SCHEMA tags;
Copy

Wenn Sie cost_management und tags als aktuelle Datenbank und aktuelles Schema ausgewählt haben, erstellen Sie ein Tag mit dem Namen cost_center und setzen die für das Tag zulässigen Werte auf die Namen der Kostenstellen:

CREATE TAG cost_center
  ALLOWED_VALUES 'finance', 'marketing', 'engineering', 'product';
Copy

Tag-Datenbank replizieren

Wenn Sie eine Organisation mit mehreren Konten haben und die Tags in diesen anderen Konten verfügbar machen möchten, richten Sie Ihre Konten für die Replikation ein und erstellen Sie eine Replikationsgruppe in einem Hauptkonto (z. B. im Organisationskonto). Richten Sie diese Replikationsgruppe ein, um die Datenbank, die die Tags enthält, zu replizieren.

Datenbank mit den Objekt-Tags replizieren

Um beispielsweise die Tags auf die Konten mit den Namen my_org.my_account und my_org.my_account_2 zu replizieren, führen Sie diese Anweisung in Ihrem Organisationskonto aus:

CREATE REPLICATION GROUP cost_management_repl_group
  OBJECT_TYPES = DATABASES
  ALLOWED_DATABASES = cost_management
  ALLOWED_ACCOUNTS = my_org.my_account_1, my_org.my_account_2
  REPLICATION_SCHEDULE = '10 MINUTE';
Copy

Erstellen Sie dann in jedem Konto, in dem Sie die Tags verfügbar machen möchten, eine sekundäre Replikationsgruppe und aktualisieren Sie diese Gruppe von der primären Gruppe aus:

CREATE REPLICATION GROUP cost_management_repl_group
  AS REPLICA OF my_org.my_org_account.cost_management_repl_group;

ALTER REPLICATION GROUP cost_management_repl_group REFRESH;
Copy

Tagging der Ressourcen und Benutzer

Nachdem Sie die Bezeichner erstellt und repliziert haben, können Sie diese Bezeichner verwenden, um die Warehouses und Benutzer zu identifizieren, die zu den einzelnen Abteilungen gehören. Da die Verkaufsabteilung zum Beispiel sowohl warehouse1 als auch warehouse2 verwendet, können Sie das Tag cost_center für beide Warehouses auf 'SALES' setzen.

Tipp

Idealerweise sollten Sie über Arbeitsabläufe verfügen, die die Anwendung dieser Tags bei der Erstellung von Ressourcen und Benutzern automatisieren.

USE ROLE tag_admin;

ALTER WAREHOUSE warehouse1 SET TAG cost_management.tags.cost_center='SALES';
ALTER WAREHOUSE warehouse2 SET TAG cost_management.tags.cost_center='SALES';
ALTER WAREHOUSE warehouse3 SET TAG cost_management.tags.cost_center='FINANCE';

ALTER USER finance_user SET TAG cost_management.tags.cost_center='FINANCE';
ALTER USER sales_user SET TAG cost_management.tags.cost_center='SALES';
Copy

Kosten nach Tag anzeigen in SQL

Sie können Kosten innerhalb eines Kontos oder kontenübergreifend in einer Organisation zuordnen:

  • Zuordnung von Kosten innerhalb eines Kontos

    Sie können Kosten innerhalb eines Kontos zuordnen, indem Sie die folgenden Ansichten im Schema ACCOUNT_USAGE abfragen:

  • Zuordnung von Kosten über Konten in einer Organisation

    Innerhalb einer Organisation können Sie auch Kosten für Ressourcen zuordnen, die ausschließlich von einer einzelnen Abteilung verwendet werden, indem Sie Ansichten im Schema ORGANIZATION_USAGE aus dem Organisationskonto abfragen.

    Bemerkung

    • Im Schema ORGANIZATION_USAGE ist die Ansicht TAG_REFERENCES nur im Konto der Organisation verfügbar.

    • Die Ansicht QUERY_ATTRIBUTION_HISTORY ist nur im Schema ACCOUNT_USAGE für ein Konto verfügbar. Es gibt kein organisationsweites Äquivalent für diese Ansicht.

In den nächsten Abschnitten wird erläutert, wie Sie die Kosten für einige der gängigen Kostenzuordnungsszenarien zuordnen:

Ressourcen, die nicht von Abteilungen geteilt werden

Angenommen, Sie möchten die Kosten nach Abteilungen zuordnen und jede Abteilung nutzt eine Reihe von speziellen Warehouses.

Wenn Sie Warehouses mit einem cost_center-Tag versehen, um die Abteilung zu identifizieren, der das Warehouse gehört, können Sie ACCOUNT_USAGE Ansicht TAG_REFERENCES mit Ansicht WAREHOUSE_METERING_HISTORY in den Spalten object_id und warehouse_id verbinden, um Nutzungsinformationen nach Warehouse zu erhalten, und Sie können die Spalte tag_value verwenden, um die Abteilungen zu identifizieren, denen diese Warehouses gehören.

TAG_REFERENCES und WAREHOUSE_METERING_HISTORY zur Zuordnung von Kosten für spezielle Warehouses verknüpfen

Die folgende SQL-Anweisung führt diese Verknüpfung durch:

SELECT
    TAG_REFERENCES.tag_name,
    COALESCE(TAG_REFERENCES.tag_value, 'untagged') AS tag_value,
    SUM(WAREHOUSE_METERING_HISTORY.credits_used_compute) AS total_credits
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
      LEFT JOIN SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES
        ON WAREHOUSE_METERING_HISTORY.warehouse_id = TAG_REFERENCES.object_id
          AND TAG_REFERENCES.domain = 'WAREHOUSE'
  WHERE
    WAREHOUSE_METERING_HISTORY.start_time >= DATE_TRUNC('MONTH', DATEADD(MONTH, -1, CURRENT_DATE))
      AND WAREHOUSE_METERING_HISTORY.start_time < DATE_TRUNC('MONTH',  CURRENT_DATE)
  GROUP BY TAG_REFERENCES.tag_name, COALESCE(TAG_REFERENCES.tag_value, 'untagged')
  ORDER BY total_credits DESC;
Copy
+-------------+-------------+-----------------+
| TAG_NAME    | TAG_VALUE   |   TOTAL_CREDITS |
|-------------+-------------+-----------------|
| NULL        | untagged    |    20.360277159 |
| COST_CENTER | Sales       |    17.173333333 |
| COST_CENTER | Finance     |      8.14444444 |
+-------------+-------------+-----------------+

Sie können eine ähnliche Abfrage durchführen, um dieselbe Zuordnung für alle Konten in Ihrer Organization vorzunehmen, indem Sie die Ansichten im Schema ORGANIZATION_USAGE aus dem Organisationskonto verwenden. Der Rest der Abfrage ändert sich nicht.

SELECT
    TAG_REFERENCES.tag_name,
    COALESCE(TAG_REFERENCES.tag_value, 'untagged') AS tag_value,
    SUM(WAREHOUSE_METERING_HISTORY.credits_used_compute) AS total_credits
  FROM
    SNOWFLAKE.ORGANIZATION_USAGE.WAREHOUSE_METERING_HISTORY
      LEFT JOIN SNOWFLAKE.ORGANIZATION_USAGE.TAG_REFERENCES
        ON WAREHOUSE_METERING_HISTORY.warehouse_id = TAG_REFERENCES.object_id
          AND TAG_REFERENCES.domain = 'WAREHOUSE'
          AND tag_database = 'COST_MANAGEMENT' AND tag_schema = 'TAGS'
  WHERE
    WAREHOUSE_METERING_HISTORY.start_time >= DATE_TRUNC('MONTH', DATEADD(MONTH, -1, CURRENT_DATE))
      AND WAREHOUSE_METERING_HISTORY.start_time < DATE_TRUNC('MONTH',  CURRENT_DATE)
  GROUP BY TAG_REFERENCES.tag_name, COALESCE(TAG_REFERENCES.tag_value, 'untagged')
  ORDER BY total_credits DESC;
Copy

Von Benutzern aus verschiedenen Abteilungen gemeinsam genutzte Ressourcen

Nehmen wir an, dass Benutzer in verschiedenen Abteilungen dieselben Warehouses nutzen und Sie die von den einzelnen Abteilungen genutzten Credits aufschlüsseln möchten. Sie können die Benutzer mit einem cost_center-Tag versehen, um die Abteilung zu identifizieren, zu der sie gehören, und Sie können Ansicht TAG_REFERENCES mit Ansicht QUERY_ATTRIBUTION_HISTORY verbinden.

Bemerkung

Sie können diese Daten immer nur für ein einzelnes Konto abrufen. Sie können keine Abfrage ausführen, die diese Daten über Konten in einer Organisation abruft.

TAG_REFERENCES und WAREHOUSE_METERING_HISTORY zur Zuordnung von Kosten für gemeinsame Warehouses verknüpfen

In den nächsten Abschnitten finden Sie Beispiele von SQL-Anweisungen für die Zuordnung von Kosten für gemeinsam genutzte Ressourcen.

Berechnung der Kosten von Benutzerabfragen für den letzten Monat

In der folgenden SQL-Anweisung werden die Kosten für den letzten Monat berechnet.

In diesem Beispiel wird die Leerlaufzeit unter den Benutzern im Verhältnis zu deren Nutzung verteilt.

WITH
  wh_bill AS (
    SELECT SUM(credits_used_compute) AS compute_credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
      WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
        AND start_time < CURRENT_DATE
  ),
  user_credits AS (
    SELECT user_name, SUM(credits_attributed_compute) AS credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
      WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
        AND start_time < CURRENT_DATE
      GROUP BY user_name
  ),
  total_credit AS (
    SELECT SUM(credits) AS sum_all_credits
    FROM user_credits
  )
SELECT
    u.user_name,
    u.credits / t.sum_all_credits * w.compute_credits AS attributed_credits
  FROM user_credits u, total_credit t, wh_bill w
  ORDER BY attributed_credits DESC;
Copy
+-----------+--------------------+
| USER_NAME | ATTRIBUTED_CREDITS |
|-----------+--------------------+
| FINUSER   | 6.603575468        |
| SALESUSER | 4.321378049        |
| ENGUSER   | 0.6217131392       |
|-----------+--------------------+

Berechnung der Kosten von Benutzerabfragen nach Abteilung ohne Leerlaufzeit

Das folgende Beispiel ordnet die Rechenkosten jeder Abteilung über die Abfragen zu, die von den Benutzern in dieser Abteilung ausgeführt werden. Diese Abfrage setzt voraus, dass die Benutzerobjekte ein Tag haben, das ihre Abteilung identifiziert.

WITH joined_data AS (
  SELECT
      tr.tag_name,
      tr.tag_value,
      qah.credits_attributed_compute,
      qah.start_time
    FROM SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES tr
      JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY qah
        ON tr.domain = 'USER' AND tr.object_name = qah.user_name
)
SELECT
    tag_name,
    tag_value,
    SUM(credits_attributed_compute) AS total_credits
  FROM joined_data
  WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
    AND start_time < CURRENT_DATE
  GROUP BY tag_name, tag_value
  ORDER BY tag_name, tag_value;
Copy
+-------------+-------------+-----------------+
| TAG_NAME    | TAG_VALUE   |   TOTAL_CREDITS |
|-------------+-------------+-----------------|
| COST_CENTER | engineering |   0.02493688426 |
| COST_CENTER | finance     |    0.2281084988 |
| COST_CENTER | marketing   |    0.3686840545 |
|-------------+-------------+-----------------|

Berechnung der Kosten für Abfragen von Benutzern ohne Leerlaufzeit

Die folgende SQL-Anweisung berechnet die Kosten pro Benutzer für den vergangenen Monat (ohne Leerlaufzeit).

SELECT user_name, SUM(credits_attributed_compute) AS credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE
    start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
    AND start_time < CURRENT_DATE
  GROUP BY user_name;
Copy
+-----------+--------------------+
| USER_NAME | ATTRIBUTED_CREDITS |
|-----------+--------------------|
| JSMITH    |       17.173333333 |
| MJONES    |         8.14444444 |
| SYSTEM    |         5.33985393 |
+-----------+--------------------+

Berechnung der Kosten für Abfragen von Benutzern ohne Tags

Das folgende Beispiel berechnet die Kosten für Abfragen von Benutzern, die nicht getaggt sind. Damit können Sie überprüfen, ob die Tags konsistent auf die Benutzer angewendet werden.

SELECT qah.user_name, SUM(qah.credits_attributed_compute) as total_credits
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY qah
    LEFT JOIN snowflake.account_usage.tag_references tr
    ON qah.user_name = tr.object_name AND tr.DOMAIN = 'USER'
  WHERE
    start_time >= dateadd(month, -1, current_date)
    AND qah.user_name IS NULL OR tr.object_name IS NULL
  GROUP BY qah.user_name
  ORDER BY total_credits DESC;
Copy
+------------+---------------+
| USER_NAME  | TOTAL_CREDITS |
|------------+---------------|
| RSMITH     |  0.1830555556 |
+------------+---------------+

Ressourcen, die von Anwendungen verwendet werden, die die Kosten verschiedenen Abteilungen zuordnen müssen

Die Beispiele in diesem Abschnitt berechnen die Kosten für eine oder mehrere Anwendungen, die von Snowflake betrieben werden.

Die Beispiele gehen davon aus, dass diese Anwendungen Abfrage-Tags setzen, die die Anwendung für alle ausgeführten Abfragen identifizieren. Um das Abfrage-Tag für Abfragen in einer Sitzung festzulegen, führen Sie den Befehl ALTER SESSION aus. Beispiel:

ALTER SESSION SET QUERY_TAG = 'COST_CENTER=finance';
Copy

Dadurch wird das Tag COST_CENTER=finance mit allen nachfolgenden Abfragen verknüpft, die während der Sitzung ausgeführt werden.

Sie können dann das Abfrage-Tag verwenden, um die durch diese Abfragen entstandenen Kosten auf die entsprechenden Abteilungen zurückzuführen.

In den nächsten Abschnitten finden Sie Beispiele für die Anwendung dieses Ansatzes.

Berechnung der Kosten für Abfragen nach Abteilung

Das folgende Beispiel berechnet die Compute-Credits und die Credits, die für den Abfrage-Beschleunigungsdienst für die Finanzabteilung verwendet werden. Dies hängt davon ab, dass das Abfrage-Tag COST_CENTER=finance auf die ursprünglich ausgeführten Abfragen angewendet wird.

Beachten Sie, dass die Kosten die Leerlaufzeit ausschließen.

SELECT
    query_tag,
    SUM(credits_attributed_compute) AS compute_credits,
    SUM(credits_used_query_acceleration) AS qas
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE query_tag = 'COST_CENTER=finance'
  GROUP BY query_tag;
Copy
+---------------------+-----------------+------+
| QUERY_TAG           | COMPUTE_CREDITS | QAS  |
|---------------------+-----------------|------|
| COST_CENTER=finance |      0.00576115 | null |
+---------------------+-----------------+------+

Berechnung der Kosten von Abfragen (ohne Leerlaufzeit) nach Abfrage-Tag

Das folgende Beispiel berechnet die Kosten von Abfragen nach Abfrage-Tag und schließt Abfragen ohne Tags (als „untagged“ gekennzeichnet) ein.

SELECT
    COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
    SUM(credits_attributed_compute) AS compute_credits,
    SUM(credits_used_query_acceleration) AS qas
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
  GROUP BY tag
  ORDER BY compute_credits DESC;
Copy
+-------------------------+-----------------+------+
| TAG                     | COMPUTE_CREDITS | QAS  |
|-------------------------+-----------------+------+
| untagged                | 3.623173449     | null |
| COST_CENTER=engineering | 0.531431948     | null |
|-------------------------+-----------------+------+

Berechnung der Kosten von Abfragen (einschließlich Leerlaufzeit) nach Abfrage-Tag

Im folgenden Beispiel wird die Leerlaufzeit, die nicht in den Kosten pro Abfrage enthalten ist, auf die Abteilungen im Verhältnis zu ihrer Nutzung des Warehouse verteilt.

WITH
  wh_bill AS (
    SELECT SUM(credits_used_compute) AS compute_credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
      WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
      AND start_time < CURRENT_DATE
  ),
  tag_credits AS (
    SELECT
        COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
        SUM(credits_attributed_compute) AS credits
      FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
      WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
      GROUP BY tag
  ),
  total_credit AS (
    SELECT SUM(credits) AS sum_all_credits
      FROM tag_credits
  )
SELECT
    tc.tag,
    tc.credits / t.sum_all_credits * w.compute_credits AS attributed_credits
  FROM tag_credits tc, total_credit t, wh_bill w
  ORDER BY attributed_credits DESC;
Copy
+-------------------------+--------------------+
| TAG                     | ATTRIBUTED_CREDITS |
+-------------------------+--------------------|
| untagged                |        9.020031304 |
| COST_CENTER=finance     |        1.027742521 |
| COST_CENTER=engineering |        1.018755812 |
| COST_CENTER=marketing   |       0.4801370376 |
+-------------------------+--------------------+

Kosten nach Tag anzeigen in Snowsight

Sie können Kosten zuordnen, indem Sie Berichte über die Verwendung von Ressourcen erstellen, die das cost_center-Tag aufweisen. Sie können unter Snowsight auf diese Daten zugreifen.

  1. Wechseln Sie zu einer Rolle, die Zugriff auf das ACCOUNT_USAGE-Schema hat.

  2. Navigieren Sie zu Admin » Cost Management.

  3. Wählen Sie Consumption aus.

  4. Wählen Sie in der Dropdown-Liste Tags das Tag cost_center aus.

  5. Um sich auf eine bestimmte Kostenstelle zu fokussieren, wählen Sie einen Wert aus der Liste der Werte des Tags aus.

  6. Wählen Sie Apply aus.

Weitere Informationen zum Filtern in Snowsight finden Sie unter Nach Tag filtern.

Allgemeine Informationen zur Ansicht QUERY_ATTRIBUTION_HISTORY

Sie können die Ansicht QUERY_ATTRIBUTION_HISTORY verwenden, um die Kosten auf der Grundlage von Abfragen zu zuzuordnen. Die Kosten entsprechen der Credit-Nutzung des Warehouse für die Ausführung der Abfrage. Diese Kosten beinhalten keine andere Credit-Nutzung, die durch die Ausführung der Abfrage entsteht. Zum Beispiel sind die folgenden Kosten nicht in den Abfragekosten enthalten:

  • Datentransferkosten

  • Speicherkosten

  • Kosten für Clouddienst

  • Kosten für serverlose Features

  • Kosten für Token, die von AI-Diensten verarbeitet werden

Bei Abfragen, die gleichzeitig ausgeführt werden, werden die Kosten des Warehouse den einzelnen Abfragen auf der Grundlage des gewichteten Durchschnitts ihres Ressourcenverbrauchs während eines bestimmten Zeitintervalls zugewiesen.

Die Kosten pro Abfrage beinhalten nicht die Leerlaufzeit des Warehouses. Die Leerlaufzeit ist ein Zeitraum, in dem keine Abfragen im Warehouse laufen und kann auf Warehouse-Ebene gemessen werden.

Weitere Beispiele für Abfragen

In den nächsten Abschnitten finden Sie weitere Abfragen, die Sie für die Kostenzuordnung verwenden können:

Gruppieren ähnlicher Abfragen

Für wiederkehrende oder ähnliche Abfragen verwenden Sie query_hash oder query_parameterized_hash, um die Kosten nach Abfrage zu gruppieren.

Um die teuersten wiederkehrenden Abfragen für den aktuellen Monat zu finden, führen Sie die folgende Anweisung aus:

SELECT query_parameterized_hash,
       COUNT(*) AS query_count,
       SUM(credits_attributed_compute) AS total_credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE start_time >= DATE_TRUNC('MONTH', CURRENT_DATE)
  AND start_time < CURRENT_DATE
  GROUP BY query_parameterized_hash
  ORDER BY total_credits DESC
  LIMIT 20;
Copy

Eine weitere Abfrage, die auf der Abfrage-ID basiert, finden Sie unter Beispiele.

Zuordnung der Kosten von hierarchischen Abfragen

Bei gespeicherten Prozeduren, die mehrere hierarchische Abfragen durchführen, können Sie die zugewiesenen Abfragekosten der Prozedur berechnen, indem Sie die Stammabfrage ID für die Prozedur verwenden.

  1. Um die Stammabfrage-ID für eine gespeicherte Prozedur zu finden, verwenden Sie die Ansicht ACCESS_HISTORY. Um zum Beispiel die Stammabfrage-ID für eine gespeicherte Prozedur zu finden, stellen Sie query_id ein und führen Sie die folgenden Anweisungen aus:

    SET query_id = '<query_id>';

SELECT query_id,
       parent_query_id,
       root_query_id,
       direct_objects_accessed
  FROM SNOWFLAKE.ACCOUNT_USAGE.ACCESS_HISTORY
  WHERE query_id = $query_id;
    Copy

    Weitere Informationen dazu finden Sie unter Beispiel: Vorgängerabfragen mit gespeicherten Prozeduren.

  2. Um die Summe der Abfragekosten für die gesamte Prozedur zu summieren, ersetzen Sie <root_query_id> und führen Sie die folgenden Anweisungen aus:

    SET query_id = '<root_query_id>';

SELECT SUM(credits_attributed_compute) AS total_attributed_credits
  FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_ATTRIBUTION_HISTORY
  WHERE (root_query_id = $query_id OR query_id = $query_id);
    Copy
Sprache: Deutsch