Verwenden der Fensterfunktionen¶

Rangbezogene Fensterfunktionen¶

Die einfachste Unterkategorie der Reihenfolge-abhängigen Funktionen ist die Unterkategorie der rangbezogenen Funktionen.

Die einfachste rangbezogene Funktion ist die Funktion RANK. Die Rangfunktion listet einfach den Rang auf, bei dem es sich um die Reihenfolge einer Zeile in einem geordneten Zeilenfenster handelt. Die erste Zeile im Fenster hat den Rang 1, die zweite Zeile im Fenster hat den Rang 2 usw. Das folgende Beispiel zeigt die Rangfolge der Verkäufer basierend auf der verkauften Menge:

+-------------+-------------+------+
| Salesperson | Amount Sold | Rank |
|-------------+-------------+------|
| Smith       |        2000 |    1 |
| Jones       |        1500 |    2 |
| Torkelson   |        1200 |    3 |
| Dolenz      |        1100 |    4 |
+-------------+-------------+------+

Copy

Die Funktion RANK führt keine Sortierung der Zeilen aus. Die Zeilen müssen im Fenster bereits in der richtigen Reihenfolge sein, bevor RANK aufgerufen wird. Verwenden Sie zum Anordnen der Zeilen die Unterklausel ORDER BY der Klausel OVER.

Betrachten Sie zur Veranschaulichung der Unterklausel ORDER BY das folgende Beispiel: Sie möchten wissen, wo Ihr Geschäftsgewinn unter den Filialen der Geschäftskette liegt, d. h. ob Ihr Geschäft an erster, zweiter, dritter usw. Stelle steht. Hier ist ein Beispiel für die Verwendung einer Reihenfolge-abhängigen Fensterfunktion, um jedes Geschäft nach der Rentabilität in seiner Stadt zu ordnen. Die Zeilen sind in absteigender Reihenfolge angeordnet (höchster Gewinn zuerst), sodass der profitabelste Laden den Rang 1 hat:

SELECT city, branch_ID, net_profit,
       RANK() OVER (PARTITION BY city ORDER BY net_profit DESC) AS rank
    FROM store_sales
    ORDER BY city, rank;
+-----------+-----------+------------+------+
| CITY      | BRANCH_ID | NET_PROFIT | RANK |
|-----------+-----------+------------+------|
| Montreal  |         3 |   10000.00 |    1 |
| Montreal  |         4 |    9000.00 |    2 |
| Vancouver |         2 |   15000.00 |    1 |
| Vancouver |         1 |   10000.00 |    2 |
+-----------+-----------+------------+------+

Copy

Die Ausgabe einer rangbezogenen Funktion hängt von folgenden Faktoren ab:

• Von der einzelnen Zeile, die an die Funktion übergeben wurde.

• Von den Werten der anderen Zeilen in dem Fenster, das an die Funktion übergeben wurde.

• Von der Reihenfolge aller Zeilen im Fenster.

Snowflake bietet verschiedene rangbezogene Funktionen. Die Namen dieser Funktionen und weitere Details zur Syntax von rangbezogenen Fensterfunktionen finden Sie unter Fensterfunktionen.

Fensterrahmenfunktionen¶

Ein Fensterrahmen enthält eine Teilmenge der Zeilen eines Fensters.

Eine Fensterrahmenfunktion verwendet einen Fensterrahmen, um beispielsweise einen gleitenden Durchschnitt zu berechnen.

Snowflake unterstützt zwei Arten von Fensterrahmen:

• Kumulativ

• Gleitend

Gleitende Fensterrahmen¶

Sie können sich einen gleitenden Fensterrahmen vorstellen, indem Sie überlegen, was Sie sehen, wenn Sie aus dem Seitenfenster eines Autos schauen, während das Auto parallel zu einem Zaun fährt. Wenn die Zaunpfosten gleichmäßig verteilt sind und die Breite des Fensters ein ganzzahliges Vielfaches des Abstands zwischen den Pfosten beträgt, bleibt die Anzahl der angezeigten Zaunpfosten konstant. Wenn Sie jedoch am Zaun entlangfahren, verschwinden „alte“ Zaunpfosten aus Ihrem Blickfeld, während „neue“ Zaunpfosten ins Blickfeld geraten, sodass Sie im Lauf der Zeit nicht dieselben Zaunpfosten sehen, aber immer die gleiche Anzahl.

Ein gleitender Fensterrahmen ist ein Rahmen mit fester Breite, der entlang der Fensterzeilen „gleitet“ und Ihnen jedes Mal einen anderen Fensterausschnitt anzeigt. Wie wenn das Auto an den Zaunpfosten entlangfährt, bewegt sich der Fensterrahmen entlang der Daten, wobei alte Zeilen aus dem Rahmen verschwinden und neue Zeilen angezeigt werden, aber die Breite des Rahmens (und damit die Anzahl der Zeilen im Rahmen) immer gleich ist.

Gleitende Fenster werden häufig zur Berechnung von gleitenden Durchschnitten verwendet. Ein gleitender Durchschnitt ist ein Durchschnitt, der auf der Grundlage eines Intervalls fester Größe (z. B. Anzahl der Tage) berechnet wird. Der Durchschnitt gleitet, weil sich die tatsächlichen Werte im Intervall mit der Zeit (oder einem anderen Faktor) ändern, wenn das Fenster verschoben wird, obwohl die Größe des Intervalls konstant ist.

Beispielsweise analysieren Börsenanalysten häufig Aktien, die teilweise auf dem gleitenden 13-Wochen-Durchschnitt des Aktienkurses basieren. Der heutige gleitende Durchschnittspreis ist der Durchschnittspreis am Ende des heutigen Tages und der Preis am Ende jedes Tages in den letzten 13 Wochen. Wenn Aktien an 5 Tagen der Woche gehandelt werden und in den letzten 13 Wochen keine Feiertage verzeichnet wurden, ist der gleitende Durchschnitt der Durchschnittspreis an jedem der letzten 65 Handelstage (einschließlich des heutigen).

Das folgende Beispiel zeigt, was mit einem gleitenden 13-Wochen-Durchschnitt (91 Tage) eines Aktienkurses am letzten Juni-Tag und an den ersten Juli-Tagen passiert:

• Am 30. Juni gibt die Funktion den Durchschnittspreis für den Zeitraum 1. April bis 30. Juni (einschließlich) zurück.

• Am 1. Juli gibt die Funktion den Durchschnittspreis für den Zeitraum 2. April bis 1. Juli (einschließlich) zurück.

• Am 2. Juli gibt die Funktion den Durchschnittspreis für den Zeitraum 3. April bis 2. Juli (einschließlich) zurück.

• usw.

Bemerkung

Obwohl Schiebefenster eine feste Breite haben, verfügt die Datenquelle beim erstmaligen Anwenden eines Fensters auf eine neue Datenquelle möglicherweise nicht über genügend Daten, um das Fenster auszufüllen. Wenn zum Beispiel die Aufzeichnung erst am 1. April begonnen hätte, dann enthielte das gleitende Fenster vom 1. April bis zum 29. Juni Daten von weniger als 91 Tagen. Die Fensterbreite bleibt erst nach dem Füllen des Fensters konstant.

Im folgenden Beispiel wird ein kleines gleitendes Fenster (3 Tage) für die ersten 7 Tage im Monat verwendet. Dies zeigt, wie der Fensterrahmen über das Fenster gleitet und immer die 3 neuesten Werte zur Berechnung der Gesamtsumme innerhalb des Fensters enthält. Diese Abbildung berücksichtigt, dass das Fenster zu Beginn des Zeitraums möglicherweise nicht voll ist:

Wie Sie der entsprechenden Tabelle entnehmen können, enthält die letzte Spalte die Umsatzsumme der letzten drei Tage. So weist beispielsweise Tag 4 einen Spaltenwert von 36 auf, was die Summe der Umsätze von Tage 2, 3 und 4 (11 + 12 + 13) ist:

+--------+-------+---------------+
| Day of | Sales | Most Recent   |
| Month  | Today | 3 Days' Sales |
|--------+-------+---------------+
|      1 |    10 |            10 |
|      2 |    11 |            21 |
|      3 |    12 |            33 |
|      4 |    13 |            36 |
|      5 |    14 |            39 |
|    ... |   ... |           ... |
+--------+-------+---------------+

Copy

Weitere Informationen zu Reihenfolge-abhängigen Fensterfunktionen¶

Die PARTITION BY- und ORDER BY-Klauseln sind unabhängig. Sie können die ORDER BY-Klausel auch ohne PARTITION BY-Klausel verwenden. Verwenden Sie die folgende Abfrage, um Ihr Geschäft mit allen anderen Geschäften der Kette zu vergleichen und nicht nur mit anderen Filialen in Ihrer Stadt:

SELECT
    branch_ID,
    net_profit,
    RANK() OVER (ORDER BY net_profit DESC) AS sales_rank
  FROM store_sales

SELECT
    branch_ID,
    net_profit,
    RANK() OVER (ORDER BY net_profit DESC) AS sales_rank
  FROM store_sales
  ORDER BY branch_ID;

Einige Fensterfunktionen sind Reihenfolge-abhängig, andere nicht.

• Einige Fensterfunktionen erfordern eine ORDER BY-Klausel.

• Einige Fensterfunktionen verbieten eine ORDER BY-Klausel.

• Einige Fensterfunktionen verwenden eine ORDER BY-Klausel, wenn eine vorhanden ist, benötigen diese jedoch nicht.

• Einige Fensterfunktionen behandeln eine ORDER BY-Klausel als implizite kumulative Fensterrahmenklausel. (Weitere Informationen zu impliziten Fensterrahmen finden Sie unter Hinweise zur Nutzung von Fensterrahmen.)

Die folgende Übersicht zeigt die Beziehung zwischen Fensterfunktionen, Fensterrahmenfunktionen und rangbezogenen Funktionen:

                      Window Functions

  Order-insensitive Functions      Order-sensitive Functions
+-----------------------------+--------------------------------------------------------------------+
|                             | Rank-related Functions                                             |
|                             +--------------------------------------------------------------------+
|                             | Functions that can be both Rank-related and Window Frame functions |
|                             +--------------------------------------------------------------------+
|                             | Window Frame Functions                                             |
+-----------------------------+--------------------------------------------------------------------+

Wie oben gezeigt:

• Einige Fensterfunktionen sind nicht Reihenfolge-abhängig.

• Bestimmte Fensterfunktionen sind Reihenfolge-abhängig.

• Die Reihenfolge-abhängigen Fensterfunktionen sind in zwei Kategorien unterteilt:

  • Rangbezogene Funktionen.

  • Fensterrahmenfunktionen

• Einige Reihenfolge-abhängige Funktionen sind sowohl rangbezogene Funktionen als auch Fensterrahmenfunktionen.

Fensterfunktionen vs. Aggregatfunktionen¶

Viele Fensterfunktionen und Aggregatfunktionen haben denselben Namen. So gibt es zum Beispiel eine Fensterfunktion SUM() und eine Aggregatfunktion SUM().

Beachten Sie Folgendes, um zwischen der Verwendung der beiden zu unterscheiden:

• Bei einer Aggregatfunktion besteht die Eingabe aus mehreren Zeilen und die Ausgabe aus der genau einer Zeile.

• Für eine Fensterfunktion gibt es zwei Eingaben, ein Zeilenfenster und eine einzelne Zeile in diesem Fenster, und die Ausgabe ist eine Zeile pro Eingabezeile.

Eine Aggregatfunktion gibt Auskunft über alle Zeilen zusammen, wie z. B. SUM, gibt jedoch nichts über die einzelnen Zeilen zurück.

Eine Fensterfunktion informiert über die aktuelle Zeile im Verhältnis zu allen anderen Zeilen im Fenster.

Die folgenden SQL-Anweisungen zeigen den Unterschied zwischen der Verwendung der Aggregatfunktion SUM(), die genau ein Zeile für die gesamte Gruppe von Eingabezeilen zurückgibt, und der Verwendung der Fensterfunktion SUM(), die eine Zeile für jede Zeile in der Gruppe der Eingabezeilen zurückgibt:

SELECT SUM(net_profit) 
    FROM store_sales;
+-----------------+
| SUM(NET_PROFIT) |
|-----------------|
|        44000.00 |
+-----------------+
SELECT branch_ID, SUM(net_profit) OVER ()
    FROM store_sales
    ORDER BY branch_id;
+-----------+-------------------------+
| BRANCH_ID | SUM(NET_PROFIT) OVER () |
|-----------+-------------------------|
|         1 |                44000.00 |
|         2 |                44000.00 |
|         3 |                44000.00 |
|         4 |                44000.00 |
+-----------+-------------------------+

Copy

Berechnen des Umsatzrankings¶

Die Spalte Rank wird mithilfe der Funktion RANK berechnet:

SELECT day, 
       sales_today, 
       RANK()
           OVER (ORDER BY sales_today DESC) AS Rank
    FROM store_sales_2
    ORDER BY day;
+-----+-------------+------+
| DAY | SALES_TODAY | RANK |
|-----+-------------+------|
|   1 |          10 |    5 |
|   2 |          14 |    3 |
|   3 |           6 |    6 |
|   4 |           6 |    6 |
|   5 |          14 |    3 |
|   6 |          16 |    2 |
|   7 |          18 |    1 |
+-----+-------------+------+

Copy

Beachten Sie, dass der Zeitraum 7 Tage umfasst, es jedoch nur 5 verschiedene Ränge gibt (1, 2, 3, 5, 6). Es gab zwei Gleichstände (für den 3. und den 6. Platz), daher gibt es keine Zeilen mit den Rängen 4 oder 7.

Berechnen der bisherigen Umsätze dieser Woche¶

Die Spalte Sales So Far This Week wird unter Verwendung von SUM als Fensterfunktion mit einem kumulativen Fensterrahmen berechnet:

SELECT day, 
       sales_today, 
       SUM(sales_today)
           OVER (ORDER BY day
               ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
               AS "SALES SO FAR THIS WEEK"
    FROM store_sales_2
    ORDER BY day;
+-----+-------------+------------------------+
| DAY | SALES_TODAY | SALES SO FAR THIS WEEK |
|-----+-------------+------------------------|
|   1 |          10 |                     10 |
|   2 |          14 |                     24 |
|   3 |           6 |                     30 |
|   4 |           6 |                     36 |
|   5 |          14 |                     50 |
|   6 |          16 |                     66 |
|   7 |          18 |                     84 |
+-----+-------------+------------------------+

Copy

Diese Abfrage ordnet die Zeilen nach Datum und berechnet dann für jedes Datum die Umsatzsumme vom Beginn des Fensters bis zum aktuellen Datum (einschließlich).

Berechnen des Gesamtumsatzes dieser Woche¶

Die Spalte Total Sales This Week wird mit SUM als einfache Fensterfunktion berechnet.

SELECT day, 
       sales_today, 
       SUM(sales_today)
           OVER ()
               AS total_sales
    FROM store_sales_2
    ORDER BY day;
+-----+-------------+-------------+
| DAY | SALES_TODAY | TOTAL_SALES |
|-----+-------------+-------------|
|   1 |          10 |          84 |
|   2 |          14 |          84 |
|   3 |           6 |          84 |
|   4 |           6 |          84 |
|   5 |          14 |          84 |
|   6 |          16 |          84 |
|   7 |          18 |          84 |
+-----+-------------+-------------+

Copy

Berechnen eines gleitenden 3-Tage-Durchschnitts¶

Die Spalte 3-Day Moving Average wird unter Verwendung von AVG als Fensterfunktion mit einem gleitenden Fensterrahmen berechnet:

SELECT day, 
       sales_today, 
       AVG(sales_today)
           OVER (ORDER BY day ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)
               AS "3-DAY MOVING AVERAGE"
    FROM store_sales_2
    ORDER BY day;
+-----+-------------+----------------------+
| DAY | SALES_TODAY | 3-DAY MOVING AVERAGE |
|-----+-------------+----------------------|
|   1 |          10 |               10.000 |
|   2 |          14 |               12.000 |
|   3 |           6 |               10.000 |
|   4 |           6 |                8.666 |
|   5 |          14 |                8.666 |
|   6 |          16 |               12.000 |
|   7 |          18 |               16.000 |
+-----+-------------+----------------------+

Copy

Der Unterschied zwischen diesem gleitenden Fensterrahmen und dem zuvor beschriebenen kumulativen Fensterrahmen ist lediglich der Anfangspunkt:

• In einem gleitenden Fensterrahmen verschiebt sich der Startpunkt nach rechts.

• In einem kumulativen Fensterrahmen ist der Startpunkt fest, und der Rahmen wird mit jeder weiteren Zeile größer.

Alle Funktionsbeispiele zusammenfügen¶

Die endgültige Version unserer Abfrage enthält Folgendes:

• Rang

• Kumulativer Fensterrahmen

• Einfache Fensterfunktion

• Gleitende Fensterfunktion

  SELECT day, 
         sales_today, 
         RANK()
             OVER (ORDER BY sales_today DESC) AS Rank,
         SUM(sales_today)
             OVER (ORDER BY day
                 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
                 AS "SALES SO FAR THIS WEEK",
         SUM(sales_today)
             OVER ()
                 AS total_sales,
         AVG(sales_today)
             OVER (ORDER BY day ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)
                 AS "3-DAY MOVING AVERAGE"
      FROM store_sales_2
      ORDER BY day;
  +-----+-------------+------+------------------------+-------------+----------------------+
  | DAY | SALES_TODAY | RANK | SALES SO FAR THIS WEEK | TOTAL_SALES | 3-DAY MOVING AVERAGE |
  |-----+-------------+------+------------------------+-------------+----------------------|
  |   1 |          10 |    5 |                     10 |          84 |               10.000 |
  |   2 |          14 |    3 |                     24 |          84 |               12.000 |
  |   3 |           6 |    6 |                     30 |          84 |               10.000 |
  |   4 |           6 |    6 |                     36 |          84 |                8.666 |
  |   5 |          14 |    3 |                     50 |          84 |                8.666 |
  |   6 |          16 |    2 |                     66 |          84 |               12.000 |
  |   7 |          18 |    1 |                     84 |          84 |               16.000 |
  +-----+-------------+------+------------------------+-------------+----------------------+
  

  Copy

Fenster mit PARTITION BY-Klausel¶

Die Unterklausel PARTITION BY der Windowing-Klausel unterteilt die Daten in verschiedene Teilmengen basierend auf dem Wert des Eingabeausdrucks. Die SELECT-Anweisung wird auf jede Teilmenge angewendet, und die Ausgabe enthält Zeilen für jede Teilmenge.

Beachten Sie, dass dies der Verwendung der GROUP BY-Klausel ähnelt, jedoch nicht mit ihr identisch ist.

Das nächste Beispiel zeigt die monatlich verkaufte Menge und teilt die Daten mit der PARTITION BY-Klausel in einmonatige Teilmengen auf:

SELECT MONTH(sales_date) AS MONTH_NUM, 
       SUM(quantity) OVER (PARTITION BY MONTH(sales_date)) AS QUANTITY
    FROM sales
    ORDER BY sales_date;
+-----------+----------+
| MONTH_NUM | QUANTITY |
|-----------+----------|
|         1 |        9 |
|         1 |        9 |
|         1 |        9 |
|         2 |        2 |
+-----------+----------+

Copy

Wie Sie sehen, sind die ersten drei Zeilen Duplikate. Es gab drei Eingabezeilen für Monat #1, und die Fensterfunktion generiert eine Ausgabezeile für jede Eingabezeile. Daher gibt es drei Ausgabezeilen für Monat #1 in der Ausgabe. Die Funktion SUM wird nicht als kumulative oder gleitende Funktion verwendet. Sie wird auf das gesamte Fenster angewendet und gibt jedes Mal den gleichen Wert für das gesamte Fenster zurück. Daher gibt die Funktion wie oben dargestellt doppelte Werte zurück.

Sie können die Duplikate mit dem Schlüsselwort DISTINCT reduzieren:

SELECT DISTINCT MONTH(sales_date) AS MONTH_NUM, 
       SUM(quantity) OVER (PARTITION BY MONTH(sales_date))
    FROM sales
    ORDER BY MONTH_NUM;
+-----------+-----------------------------------------------------+
| MONTH_NUM | SUM(QUANTITY) OVER (PARTITION BY MONTH(SALES_DATE)) |
|-----------+-----------------------------------------------------|
|         1 |                                                   9 |
|         2 |                                                   2 |
+-----------+-----------------------------------------------------+

Copy

In diesem speziellen Fall können Sie eine GROUP BY-Klausel anstelle einer Windowing-Klausel verwenden. Beispiel:

SELECT MONTH(sales_date) AS MONTH_NUM, 
       SUM(quantity)
    FROM sales
    GROUP BY MONTH_NUM
    ORDER BY MONTH_NUM;
+-----------+---------------+
| MONTH_NUM | SUM(QUANTITY) |
|-----------+---------------|
|         1 |             9 |
|         2 |             2 |
+-----------+---------------+

Copy

GROUP BY ist jedoch nicht so flexibel wie Windowing. Außerdem können Sie GROUP BY in komplexeren Abfragen nicht immer durch eine Fensterklausel ersetzen.

Fenster mit ORDER BY-Klausel¶

Die ORDER BY-Klausel steuert die Reihenfolge der Daten in jedem Fenster (und jeder Partition, wenn es mehr als eine Partition gibt). Dies ist nützlich, wenn Sie im Laufe der Zeit, in der immer wieder neue Zeilen hinzugefügt werden, eine „aktuelle Summe“ anzeigen möchten.

Eine laufende Summe kann entweder vom Anfang des Fensters bis (inklusive) zur aktuellen Zeile berechnet werden oder von der aktuellen Zeile bis zum Ende des Fensters.

Eine Abfrage kann ein „gleitendes“ Fenster verwenden, bei dem es sich um ein Fenster mit fester Breite handelt, das N angegebene Zeilen relativ zur aktuellen Zeile verarbeitet (beispielsweise die 10 neuesten Zeilen, einschließlich der aktuellen Zeile).

Nachfolgend werden sowohl kumulative als auch gleitende Fenster erläutert.

Fenster mit PARTITION BY- und ORDER BY-Klauseln¶

Sie können PARTITION BY- und ORDER BY-Klauseln kombinieren, um aktuelle Summen in Partitionen abzurufen. In diesem Beispiel ist die Partition auf einen Monat festgelegt. Da die Summen nur für eine Partition gelten, wird die Summe zu Beginn jedes neuen Monats auf 0 zurückgesetzt:

SELECT MONTH(sales_date) AS MONTH_NUM,
       SUM(quantity) OVER (PARTITION BY MONTH(sales_date) ORDER BY sales_date)
          AS MONTHLY_CUMULATIVE_SUM_QUANTITY
    FROM sales
    ORDER BY sales_date;

Copy

Das Abfrageergebnis enthält zusätzliche Kommentare, aus denen hervorgeht, wie die Spalte MONTHLY_CUMULATIVE_SUM_QUANTITY berechnet wurde:

+-----------+---------------------------------+
| MONTH_NUM | MONTHLY_CUMULATIVE_SUM_QUANTITY |
|-----------+---------------------------------+
|         1 |                               1 |  -- sum = 1
|         1 |                               4 |  -- sum = 1 + 3
|         1 |                               9 |  -- sum = 1 + 3 + 5
|         2 |                               2 |  -- sum = 0 + 2 (new month)
+-----------+---------------------------------+

Copy

Sie können Partitionen und gleitende Fenster kombinieren. Im folgenden Beispiel ist das gleitende Fenster normalerweise zwei Zeilen breit. Jedes Mal, wenn eine neue Partition (d. h. ein neuer Monat) erreicht wird, beginnt das gleitende Fenster bei der ersten Zeile dieser Partition:

SELECT
       MONTH(sales_date) AS MONTH_NUM,
       quantity,
       SUM(quantity) OVER (PARTITION BY MONTH(sales_date) 
                           ORDER BY sales_date
                           ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) 
         AS MONTHLY_SLIDING_SUM_QUANTITY
    FROM sales
    ORDER BY sales_date;

Copy

Das Abfrageergebnis enthält zusätzliche Kommentare, aus denen hervorgeht, wie die Spalte MONTHLY_SLIDING_SUM_QUANTITY berechnet wurde:

+-----------+----------+------------------------------+
| MONTH_NUM | QUANTITY | MONTHLY_SLIDING_SUM_QUANTITY |
|-----------+----------+------------------------------+
|         1 |        1 |                           1  |  -- sum = 1
|         1 |        3 |                           4  |  -- sum = 1 + 3
|         1 |        5 |                           8  |  -- sum = 3 + 5
|         2 |        2 |                           2  |  -- sum = 0 + 2 (new month)
+-----------+----------+------------------------------+

Copy