Referenz zur Monitoring-Abfragesprache

Dies ist ein Referenzhandbuch für die Monitoring-Abfragesprache von Cloud Monitoring. Es deckt folgende Themenbereiche ab:

Das Datenmodell, das der Zeitachsendatenbank zugrunde liegt, auf die die Monitoring-Abfragesprache zugreift.
Die Struktur und Semantik von Abfragen
Eine Beschreibung aller Vorgänge und Funktionen, aus denen eine Abfrage erstellt wird.

Datenmodell

Cloud Monitoring verwendet eine Zeitachsendatenbank, die alle Messwerte enthält, die zu jeder überwachten Ressource aufgenommen wurden. Dies wird als überwachte Ressource bezeichnet. Dies beschreibt die logische Struktur dieser Datenbank.

Das grundlegende Element ist eine Zeitachse, deren Daten aus Beobachtungen der überwachten Ressource bestehen.

Zeitachsen sind in der Datenbank in relationalen Tabellen logisch organisiert, wobei jede Tabelle Zeitachsen mit einer gemeinsamen Bedeutung und Struktur enthält. Auf die Tabellen wird durch Abfragen verwiesen, die Daten zurückgeben, Grafiken generieren und Warnungen berechnen.

Die Datenbank enthält auch Metadaten, bei denen es sich um langsam ändernde Werte handelt, die mit einer überwachten Ressource verknüpft sind und von der Nutzerkonfiguration oder vom Dienst festgelegt werden, der den Typ der überwachten Ressource implementiert.

Zeitachse

Eine Zeitachse ist eine benannte Abfolge von Punkten, die jeweils ein Messwert und die Zeit sind, für die der Wert gilt. Eine Zeitachse besteht aus drei Teilen: einem Typ, der die Struktur der Zeitachsen angibt, einer Kennung, die die Zeitachsen eindeutig identifiziert und einem Verlauf, der die Zeitachsendaten enthält. Jeder dieser drei Teile wird in diesem Abschnitt erläutert.

Ein Zeitachsentyp gibt die Struktur der Zeitachsenkennzeichnung und den Zeitachsenverlauf an. Sie besteht aus zwei Teilen:

Ein Typ der überwachten Ressource (aufgeführt hier klicken ), die eine bestimmte Art von überwachter Ressource benennt, die überwacht wird, wie eine Compute Engine-Instanz (gce_instance ) oder eine Cloud SQL-Datenbank (cloudsql_database ). Er hat eine Reihe von Labeldeskriptoren, die eine Instanz dieses Typs von überwachten Ressourcen eindeutig identifizieren.
Ein Messwerttyp (hier aufgeführt) , der eine bestimmte Art von Messung beschreibt, die auf eine überwachte Ressource übertragen werden kann. Beispiel: Der von einer Compute Engine-Instanz gelesene Byte wird anhand des Messwerts namens compute.googleapis.com/instance/disk/read_bytes_count und die Datenauslastung einer Cloud SQL-Datenbank anhand des Messwerts namens cloudsql.googleapis.com/database/disk/bytes_used gemessen. Der Messwerttyp gibt den Typ des Messwerts, die Einheiten der Messung und die Art der Zeitachse an. Es kann Label-Deskriptoren angeben, die Zeitachsen unterscheiden, die verschiedene Aspekte derselben Sache messen. Beispiel: command, der angibt, welcher Befehl im Messwert appengine.googleapis.com/memcache/operation_count gezählt wird.

Ein überwachter Ressourcentyp und ein Messwerttyp werden jeweils durch ein MonitoredResourceDescriptor und ein MetricDescriptor beschrieben. Diese beschreiben die Typen. Sie enthalten jeweils ein Feld namens type, das den Namen der überwachten Ressource oder des Messwerttyps enthält.

Eine Zeitachsenkennzeichnung ist der Name der Zeitachse, die sie unter allen Zeitachsen mit demselben Typ eindeutig identifiziert. Sie besteht aus einer Reihe von Werten, jeweils einem für die Label-Deskriptoren, die in den überwachten Ressourcen- und Messwerttypen des Zeitachsentyps angegeben sind.

Die Labels des Typs "Überwachte Ressource" identifizieren eindeutig die bestimmte Instanz der Art der überwachten Ressource, von der die Messungen in der Zeitachse stammen. Die überwachte gce_instance-Ressource hat beispielsweise die Labels project_id, instance_id und zone, die eine bestimmte virtuelle Google Compute Engine-Maschine eindeutig identifizieren.
Jedes Label des Messwerttyps gibt an, welche Art von Messung für den jeweiligen Messwert in der Zeitachse dargestellt wird. Beispielsweise kann status, das den Status der im Messwert appengine.googleapis.com/memcache/operation_count gezählten Befehle angibt, den Wert 'HIT' für eine Zeitachse haben, die Treffer zählt, und 'MISS' für eine andere Zeitachse, die Fehler zählt.

Ein Zeitachsenverlauf ist eine geordnete Abfolge von Punkten, die jeweils eine gleichzeitige Messung der Messungen darstellen, oder potenziell mehrere Werte (z. B. CPU-Auslastung oder Temperatur und Luftfeuchtigkeit) zu einem bestimmten Zeitpunkt oder über einen gewissen Zeitraum hinweg. Ein Punkt besteht aus zwei Elementen:

Der Umfang eines Punkts besteht aus einer Endzeit, die immer vorhanden ist, und einer Startzeit, die vorhanden sein kann oder nicht. Wenn die Startzeit nicht vorhanden ist, ist die Ausdehnung des Punkts ein einzelner Zeitpunkt, der durch die Endzeit angegeben wird. Wenn eine Startzeit angegeben ist, muss diese vor der Endzeit liegen und die Ausdehnung des Punkts ist das Zeitintervall, das zur Startzeit beginnt und zur Endzeit endet.

Kein Punkt in einer Zeitachse kann dieselbe Ausdehnung haben. Darüber hinaus werden die Ausdehnungen der Punkte in einer Zeitachse durch die Art der Zeitachse beschränkt, die vom Messwerttyp angegeben wird, wie unten beschrieben.
Der Wert eines Punkts stellt eine gleichzeitige Messung eines oder möglicherweise mehrerer Werte (z. B. CPU-Auslastung oder Temperatur und Luftfeuchte) dar, die für die durch die Ausdehnung des Punktes angegebene Zeit gilt. Der Messwerttyp beschreibt jeden Messwert und gibt ihm jeweils einen Namen und einen Werttyp. Wenn mehrere Messwerte vorhanden sind, befinden sie sich in einer bestimmten Reihenfolge und können durch ihren Index in dieser Reihenfolge referenziert werden.

Eine typische Zeitachse, die in der Zeitachsendatenbank gespeichert ist, hat in jedem Punkt einen einzelnen Wert. Der Name des Messwerts im Zeitachsentyp ist ein URI und der Name des einzelnen Werts ist der Teil des Messwertnamens nach dem letzten /. Der Messwert appengine.googleapis.com/memcache/operation_count hat beispielsweise eine Wertspalte mit dem Namen operation_count.

Eine Zeitachse, die die Ausgabe einer Abfrage ist, kann mehrere Punkte haben, deren Typ, Name und Reihenfolge von der Abfrage angegeben werden.

Der Messwerttyp kann auch Maßeinheiten für den Zeitachsenwert angeben, wenn er vom Int, Double, oder Distribution ist. Die Einheiten werden mit einer Teilmenge des Unified Code for Units of Measures (UCUM) angegeben. Zum Beispiel ms für Millisekunden oder By für Byte. Weitere Informationen finden Sie unter Maßeinheiten.

Jeder Wert in einem Punkt hat einen bestimmten Werttyp, der durch den Messwerttyp im Zeitachsentyp angegeben wird. Außerdem hat jedes Label in der Zeitachsenkennung einen Werttyp, der durch den Labeldeskriptor in der überwachten Ressource oder dem Messwerttyp des Zeitachsentyps angegeben wird. Die Werttypen lauten so:

Int: Eine 64-Bit-Ganzzahl mit Vorzeichen.
String: Ein UTF-8-codierter Unicode-String.
Bool (Boolescher Wert): Ein boolescher Wert.
Double (Gleitkommazahl mit doppelter Genauigkeit): Ein 64-Bit-IEEE-Gleitkommawert.
Verteilung: Ein komplexer Wert, der ein Histogramm und Statistiken enthält, die eine Zusammenfassung der Gesamtheit von Double-Werten enthalten. Die folgenden Teile dieses Werts sind:
- Die Anzahl der Werte in der Population.
- Summe der Werte in der Population
- Die Summe der quadratischen Abweichung der Werte in der Population
- Eine Bucket-Spezifikation, die die Grenzen zwischen Buckets im Histogramm angibt. Ein Bucket enthält eine Anzahl der Werte, die zwischen der Unter- und Obergrenze des Buckets liegen.
- Ein Histogramm, das die Anzahl der Werte angibt, die in jeden Bucket fallen.
Diese Teile reichen aus, um zusätzlich den Mittelwert, die Varianz, die Standardabweichung und die Schätzungen von Perzentilen zu berechnen.

Der Typ eines Punktwerts kann einer der oben genannten sein. Ein Label-Typ für die Zeitachsenkennung darf nur String, Int oder Bool sein.

Zusätzlich zu diesen Typen gibt es zwei weitere Typen, die sich in der Start- und Endzeit eines Punkts befinden oder zum Beschreiben von Zeiten und Dauer in Abfragen verwendet werden.

Datum: Ein bestimmter Zeitpunkt, der ab der Unix-Epoche gemessen wird. Es ist eine zonenunabhängige Darstellung eines bestimmten Zeitpunkts. Die Start- und Endzeit eines Punkts ist vom Typ.
Dauer: Ein Zeitraum. Diese Zeit hat keine bestimmte Maßeinheit (obwohl die Auflösung im Mikrosekundenbereich liegt), sondern nimmt eine bestimmte Einheit (z. B. Sekunden) an, wenn sie in ein Int oder Double umgewandelt wird.

Die Menge der Werte für jeden Typ (außer Datum und Dauer ) enthält einen Wert mit der Bezeichnung no-value Dies bedeutet, dass es keinen bestimmten Wert gibt. Und wird in zwei Fällen verwendet:

Wenn kein bestimmter Wert bekannt ist, z. B. wenn ein Fehler vorliegt (z. B. Teilen durch 0), der die Berechnung eines Werts verhindert.
No-value ist der Wert eines Labels in einer Zeitachsenkennzeichnung, wenn das Label für den Zeitachsentyp erforderlich ist, aber kein Wert bekannt ist. Dies kann passieren, wenn bei der Erfassung des Messwerts kein Wert bekannt ist oder wenn die Zeitachse von einer Abfrage generiert wurde und die Berechnung, die den Labelwert generiert hat, keinen Wert erzeugt hat. Beachten Sie, dass No-value ein separater Wert ist und damit die Zeitachsenkennzeichnung von allen anderen Werten unterscheidet, die für das angegebene Label einen tatsächlichen Wert haben.

No-value unterscheidet sich von einem IEEE NaN und einem Stringwert, der der leere String ist. Es ist nicht möglich, dass ein Wert in einem Punkt no-value ist.

Die Zeitachsenart beschreibt die Bedeutung der Werte der Punkte in einer Zeitachse und schränkt die Darstellungen jedes Punkts ein. Es gibt drei Arten von Zeitachsen:

Anzeige: Der Wert eines Punktes in einer Anzeigen-Zeitachse ist eine Messung zum Endzeitpunkt des Punktes. Ein Punkt in einem Anzeigen-Stream hat keine Startzeit, daher ist sein Umfang ein einzelner Zeitpunkt. Der Wert eines Punkts kann eines der folgenden Elemente darstellen:
- Ein Beispiel für eine Variable, z. B. die Länge einer Warteschlange oder ein belegter Arbeitsspeicher.
- Eine Zustandsform, die zur Endzeit eines Punkts vorlag und bis zur Endzeit des nächsten Punkts fortbesteht
- Eine Zusammenfassung einer bestimmten Menge (Mittelwert, Maximum usw.), die für den Zeitraum zwischen dem Punkt und dem nächsten jüngeren Punkt in der Zeitachse gilt.
Delta: Bei numerischen Werten (Int oder Double) stellt jeder Punkt die Änderung eines gemessenen Werts über die Ausdehnung des Punkts dar, d. h. zwischen der Startzeit des Punkts (falls vorhanden) und der Endzeit. Für den Wert einer Verteilung gibt es eine Füllung der numerischen Werte, die während der Ausdehnung des Punkts entstanden sind. Eine Zeitachse vom Typ Delta muss den Werttyp Int, Double oder Distribution haben.

Bei einer Delta-Zeitreihe können sich die Ausdehnungen von zwei beliebigen Punkten nicht überlappen, sodass jeder Punkt eine unabhängige Änderung des gemessenen Wertes (numerisch) oder einer disjunkten Wertepopulation (Verteilung) darstellt. Idealerweise beginnt der Umfang jedes Punkts unmittelbar nach dem Ende des nächsten jüngeren Punkts, sodass die Zeitachse eine vollständige Beschreibung des Zeitraums darstellt, der behandelt wird.
Cumulative (Kumulativ): Dies kann man sich als Zeitachse der Art Delta mit überlappenden Ausdehnungen vorstellen. Die Einschränkung besteht darin, dass zwei Punkte, die überlappende Umfänge haben, dieselbe Startzeit haben müssen. Somit repräsentiert jeder Punkt eine kumulative Zunahme eines bestimmten gemessenen Werts gegenüber dem letzten Punkt mit einer gemeinsamen Startzeit.

Kumulative Messwerte stellen eine robuste Methode zum Erfassen von Zeitachsen aus externen Datenquellen dar:
- Die Quelle muss keine Zähler oder Akkumulatoren bei jeder Erfassung eines Werts zurücksetzen und kann leicht in mehreren Zeiträumen überwacht werden.
- Akkumulierte Zählungen gehen nicht verloren, wenn einige Punkte fehlen. Der nächste Punkt enthält alle Zählungen seit der Startzeit, einschließlich derjenigen vom fehlenden Punkt. Nur die zeitliche Auflösung geht verloren.
In Abfragen werden kumulative Zeitachsen jedoch nicht häufig berücksichtigt. Um Vorgänge für Zeitachsen, die von Abfragen zurückkommen, einfacher zu gestalten, wird eine kumulative Zeitachse, wenn sie abgerufen wird, automatisch in eine Delta-Zeitachse umgewandelt, indem die Ausdehnung jedes Punkts zum Zeitpunkt des nächstjüngeren Punkts beginnt und ihr Wert die Änderung seit diesem nächstjüngeren Punkt ist. Die vorhandenen Informationen bleiben unverändert, aber jeder Punkt ist unabhängig von den anderen. Dies kann durch fetch_cumulative überschrieben werden.

Bei Zeitachsen, deren Punkte mehr als einen Wert haben, hat jeder Wert eine Zeitachsenart, die nur Gauge oder Delta sein kann. Wenn ein Wert die Art Delta hat, hat der Gesamtmesswert die Art Delta (und somit hat jeder Punkt eine Start- und Endzeit). Andernfalls hat der Messwert die Art Gauge (und nur eine Endzeit).

Tabellen

Alle Zeitachsen mit demselben Zeitachsentyp (Typ der überwachten Ressource und Messwerttyp) sind logisch in einer relationalen Tabelle organisiert. Die Tabelle hat einen Tabellennamen, der aus dem Namen des überwachten Ressourcentyps gefolgt vom Namen des metrischen Typs besteht.

Eine Tabelle enthält eine Zeile pro Punkt aus jeder Zeitachse, die sich in der Tabelle befindet. Die Tabelle setzt sich aus folgenden Arten von Spalten zusammen:

Zeitachsen-ID-Spalten Eine Spalte für jedes Label der Zeitachsen-ID, wie von den überwachten Ressourcen- und Messwerttypen angegeben. Der Name der Spalte ist der Name des Labels (sein Schlüssel) und der Typ der Spalte ist der Wertetyp des Labels. Wenn ein Label für eine überwachte Ressource und ein Messwertlabel denselben Namen haben, wird dem Namen der Spalte mit dem Messwertlabel metric. vorangestellt.

Eine Zeitachse besteht aus allen Zeilen in einer Tabelle mit demselben Wert für jede der entsprechenden Zeitachsenkennzeichnungsspalten.
Zeitspalte oder -spalten, abgeleitet von der Ausdehnung der Punkte in der Zeitreihe. Es gibt immer eine Endzeitspalte, auf die über die Funktion end() zugegriffen wird (tatsächlich geben wir der Spalte aber keinen Namen). Wenn der Messwert vom Typ Delta ist, gibt es eine Startzeitspalte, auf die von der Funktion start() aus zugegriffen werden kann. (Es gibt auch eine Startzeitspalte für Messwerte mit der Art "Kumulative Zeitachse".) Beide Spalten haben Werte vom Typ Date.
Wert-Spalten, eine für jeden Wert im Wert der Punkte der Zeitachse. Jede Spalte hat den Namen und den Typ dieses Werts und die Wertspalten befinden sich in derselben Reihenfolge wie der Messwerttyp. Wenn ein überwachtes Ressourcen- oder Messwertlabel mit dem gleichen Namen wie ein Wertname vorhanden ist, erhält der vom Messwerttyp angegebene Wertname das Präfix value., um den Spaltennamen zu bilden.

Alle Punkte in einer Zeitachse haben den gleichen Wert in den Zeitachsenkennzeichnungs-Spalten und diese Spalten identifizieren eindeutig Zeitachsen. Die Zeitachsenspalten und die Endzeitspalte bilden den Primärschlüssel der Tabelle und identifizieren eine Zeile und somit einen Punkt zweifelsfrei.

Oben wurde eine gespeicherte Tabelle beschrieben, die aus Zeitachsen besteht, die in der Datenbank gespeichert sind. Eine Abfrage umfasst gespeicherte Tabellen als erste Eingaben und führt nachfolgende Tabellenvorgänge aus (Filterung, Aggregation, Zusammenführung usw.), wobei als Ergebnis dieser Tabellenvorgänge abgeleitete Zwischentabellen entstehen.

Eine abgeleitete Tabelle hat dieselbe Struktur wie eine gespeicherte Tabelle mit folgenden Unterschieden:

Die Tabelle ist weiterhin einem überwachten Ressourcentyp zugeordnet, wenn die Transformation, die sie erzeugt hat, alle Spalten mit den überwachten Ressourcenlabels beibehalten hat. Ansonsten ist sie keinem Typ von überwachter Ressource zugeordnet. Dies ist für Metadaten wichtig, die im nächsten Abschnitt beschrieben werden.
Die Tabelle wird durch einen Tabellentyp und nicht durch einen Typ von überwachter Ressource und einen Messwerttyp beschrieben. Der Tabellentyp entspricht einem Messwerttyp, mit der Ausnahme, dass der Satz von Labels alle Spalten der Zeitachsenkennzeichnung enthält. Abhängig von der tatsächlichen Ableitung der Tabelle haben die Zeitachsenkennzeichnungsspalten möglicherweise keine Beziehung zu den Spalten, die von einem tatsächlichen Typ von überwachter Ressource oder einem Messwerttyp angegeben wurden.
Eine abgeleitete Tabelle hat keinen Namen.

Metadata

Ein Typ einer überwachten Ressource kann Metadatentypen haben, die jeder Instanz eines bestimmten Typs einer überwachten Ressource einen Wert zuordnen. Jeder Metadatentyp hat einen Namen und einen Werttyp (String, Int oder Bool).

Es gibt zwei Arten von Metadaten:

Systemmetadaten, die vom Dienst erstellt werden, der die überwachte Ressource erstellt und verwaltet. Systemmetadaten haben den Namen metadata.system_labels.<key>, wobei <key> eine bestimmte Art von Metadaten identifiziert.
Nutzermetadaten, die vorhanden sind, wenn ein Dienst dem Nutzer das Hinzufügen von Labels zu einer bestimmten überwachten Ressource ermöglicht. Nutzermetadaten haben den Namen metadata.user_labels.<key>, wobei <key> der Schlüssel des Labels ist, das der Nutzer der Entität zugeordnet hat. Beispiel: metadata.user_labels.my_key. Der Wert von Nutzermetadaten ist immer vom Typ String.

Eine Tabelle (gespeichert oder abgeleitet), die einer überwachten Ressource zugeordnet ist, kann zusätzliche Spalten für virtuelle Werte haben, eine für jeden Metadatentyp, der dem Typ der überwachten Ressource zugeordnet ist. Für jede Zeile in der Tabelle enthält eine Metadatenspalte den Wert dieser Metadaten zum Zeitpunkt der Endzeitspalte der Zeile. Diese zusätzlichen Metadatenspalten sind nicht Teil der Tabelle, können jedoch in Abfrageausdrücken referenziert werden, so als wären sie die Namen der Metadaten in den Ausdrücken, die für eine Tabellenzeile verwendet werden.

Ausrichtung

Eine Zeitachse ist zeitlich ausgerichtet (oder nur ausgerichtet), wenn die Endzeit ihrer Punkte nur in regelmäßigen Abständen auftritt. Wir sagen, dass eine Zeitachse in Bezug auf eine bestimmte Ausrichtungszeit und einen bestimmten Ausrichtungszeitraum ausgerichtet ist, wenn jeder Punkt in der Zeitreihe eine Endzeit hat, die ein Vielfaches der Ausrichtungsperiode vor (oder nach) der Ausrichtungsbasiszeit ist. Bei einer Ausrichtungsbasiszeit von 10:03 Uhr und einer Ausrichtungsperiode von 5 Minuten wären beispielsweise 09:48, 09:53, 09:58, 10:03, 10:08 Uhr alles gültige Endzeiten für Punkte.

Wenn die Zeitachsen einer Tabelle den Zeitachsentyp Delta haben, muss die Startzeit jedes Punkts um die Dauer des Zeitraums vor der Endzeit liegen, sodass die Dauer jedes Punkts gleich lang ist. Eine Tabelle mit kumulativen Startzeiten kann nicht ausgerichtet werden, da es generell nicht möglich ist, die Startzeiten von Punkten zwischen verschiedenen Zeitachsen abzugleichen.

Wenn alle Zeitachsen, aus denen eine Tabelle besteht, auf dieselbe Ausrichtungszeit und denselben Zeitraum ausgerichtet sind, wird die Tabelle auf diese Zeit und diesen Zeitraum ausgerichtet.

Wenn eine Tabelle ausgerichtet ist, werden die Punkte in verschiedenen Zeitachsen zeitlich aufeinander abgestimmt. Dies ermöglicht es, Vorgänge auszuführen, die verschiedene Zeitachsen kombinieren. Wenn Sie beispielsweise die Zeitachse abrufen möchten, bei der es sich um die Summe eines Messwerts für alle überwachten Ressourcen handelt, müssen die Punkte in den einzelnen Zeitachsen übereinstimmen, also dieselbe Ausrichtung aufweisen. Dann ist der Wert der Punkte in der resultierenden Zeitreihe die Summe der Werte der Punkte zur gleichen Zeit in den einzelnen Zeitreihen.

Syntax und Semantik

Lexikalische Elemente

Der Text einer Abfrage besteht aus einer Abfolge von Token, die in der Grammatik unten durch folgende Regeln definiert sind:

Ein Token wird in der Grammatik unten durch eines der großgeschriebenen, nicht-terminalen Symbole beschrieben.
Ein anderes Token als base_string enthält keinen Leerraum. Ein Leerraum ist ein Leerzeichen, Tabulator, Zeilenumbruch und Kommentar. Ein Kommentar ist ein beliebiger Text, der nicht in einem base_string befindet und mit # beginnt und mit einem Zeilenumbruch endet.
Leerzeichen zwischen Tokens werden ignoriert, mit Ausnahme von separaten Tokens.
Zwei benachbarte Token müssen durch Leerraum getrennt sein, wenn diese Grammatik zulässt, dass sie als einzelnes Token erkannt werden. Eine Ausnahme bildet BARE_NAME , das nur in bestimmten Kontexten erkannt wird.

ID : letter { letter_num_under } .
QUOTED_COLUMN : ( 'c' | 'C' ) base_string .
BARE_NAME : ( '/' | letter_num_under ) { letter_num_under | '.' | '/' | '-' } .
NUMBER : digit { digit } [ fraction | '.' ] [ exponent ] | fraction [exponent] .
STRING : [ 'r' | 'R' ] base_string .
DURATION : digit { digit } ( 's' | 'ms' | 'us' | 'm' | 'h' | 'd' | 'w' ) .
DATE : ( 'd' | 'D' ) base_string .

letter_num_under : letter | digit | '_' .
base_string : '\'' any-but-quote '\'' | '"' any-but-quote-quote '"' .
fraction : '.' digit { digit } .
exponent : ( 'e' | 'E' ) [ '-' | '+' ] digit { digit } .

letter - an ASCII letter
digit  - an ASCII digit
any-but-quote - any Unicode character except the ASCII control codes or `'`.
any-but-quote-quote - any Unicode character except the ASCII control codes or `"'.

Kennzeichnungen (ID) werden verwendet, um die integrierten Tabellenvorgänge und -funktionen, die Teil der Monitoring-Abfragesprache sind, sowie Spalten und Metadaten in Ausdrücken zu benennen. Die Syntax unterscheidet zwischen einer Stelle, an der eine ID ein Name für einen Tabellenvorgang oder eine Tabellenfunktion sein kann, und einer Stelle, an der eine ID ein Spaltenname sein kann. Daher gibt es keine "reservierten" Kennzeichnungen, die nicht als Spaltennamen verwendet werden können. Mit QUOTED_COLUMN wird der Name einer Spalte angegeben, die nicht als Kennzeichnung geparst wird. Beispiel: c'total cpu'

Die Token NUMBER, STRING, DURATION und DATE kennzeichnen Literalwerte. Auf NUMBER kann ein unit folgen, das die Maßeinheiten dieses Literalwerts als STRING angibt. Ein STRING kann Unicode-Zeichen enthalten. Wenn ihm kein r oder R vorangestellt ist, werden die normalen Escapesequenzen erkannt. Das Suffix eines DURATION gibt an, wie eine Zeitdauer angegeben wird: Sekunden, Millisekunden, Mikrosekunden, Minuten, Stunden, Tage oder Wochen. base_string in einem Datum enthält ein Datum im Format 2010/06/23-19:32:15-07:00, wobei das erste - ein Leerzeichen sein kann und die Zeitzone (-07:00) (sowie die Sekunden, Minuten, oder Stunden) weggelassen werden kann.

Die verbleibenden Tokens sind Satzzeichen und Operator-Tokens, die in der folgenden Grammatik in Anführungszeichen stehen (z. B. '^' oder '<='). Diese Tokens sind ^, <=, <, ==, = =~, >=, >, ||, |, _, -, ,, ;, ::, :, !=, <>, !~, !, //, /, ., (, ), [, ], {, }, *, &&, %, +.

Abfragestruktur

Eine Abfrage besteht aus einer Folge von Tabellenvorgängen (table_op), die durch Pipe-Operatoren (|) verbunden sind. Jeder Tabellenvorgang nimmt Tabellen als Eingaben an und erzeugt Tabellen als Ausgabe. Die von einem Tabellenvorgang ausgegebenen Tabellen werden in den nächsten Tabellenvorgang geleitet, der sie verwendet, um eine eigene Tabellenausgabe zu erzeugen.

query : table_op { '|' table_op } .
table_op : basic_table_op | grouped_table_op | shortcut_table_op .

basic_table_op : ID [ arg { ',' arg } ] .
arg : table_name | expr | map .

grouped_table_op:  '{' query { ';' query } '}' .

Es gibt drei Arten von Tabellenvorgängen (table_op).

Ein basic_table_op beginnt mit einem ID, das die auszuführende Art des Vorgangs angibt (hier beschrieben). Darauf folgen Argumente (arg), die Details zur Ausführung des Tabellenvorgangs enthalten. Jede Art von basic_table_op nimmt null, eine oder viele Tabellen als Eingabe an und erzeugt eine Tabelle als Ausgabe.
Ein grouped_table_op besteht aus einer geordneten Liste von Abfragen. Jede Abfrage erzeugt eine Tabelle und das Ergebnis von grouped_table_op ist eine geordnete Liste dieser Tabellen. Jede Abfrage nimmt als Eingabe null oder mehr Eingabetabellen an, die die Eingabe für grouped_table_op sind.
Ein shortcut_table_op ist eine Tastenkombination, die hier für basic_table_op beschrieben wird.

Die von einem table_op ausgegebenen Tabellen werden vom Pipe-Operator (|) als Eingabe an den nächsten table_op übergeben. Im Folgenden finden Sie die Regeln für die Übergabe von Tabellen, die von einem Tabellenvorgang links neben einem Pipe-Operator (dem Ersteller) an einen Tabellenvorgang rechts vom Pipe-Operator (dem Nutzer) ausgegeben werden:

Ein Tabellenvorgang, der keine Tabelleneingabe annimmt, kann kein Verbraucher sein.
Bei einem Erzeuger, der eine einzige Tabelle ausgibt, und einem Verbraucher, der eine einzige Tabelle annimmt, ist die Ausgabetabelle des Erzeugers eine Eingabe für den Verbraucher.
Bei einem Erzeuger, der mehrere Tabellen ausgibt, und einem Verbraucher, der eine einzige Tabelle annimmt, wird der Verbraucher separat auf jede Eingabetabelle angewendet und die Ausgabe des Verbrauchertabellenvorgangs ist genau eine Tabelle pro Eingabetabelle.
Bei einem Erzeuger, der mehrere Tabellen ausgibt, und einem Verbraucher, der mehrere Tabellen annimmt, sind alle erzeugten Tabellen eine Eingabe für den Verbraucher.
Für einen Erzeuger, der eine einzelne Tabelle erstellt, und einen Verbraucher, der ein grouped_table_op ist, ist die einzelne Tabelle die Eingabe für den ersten Tabellenvorgang jedes query in der grouped_table_op.
Es ist nicht gültig, dass ein grouped_table_op ein Verbraucher für einen Erzeuger ist, der mehrere Tabellen erstellt.
Der letzte table_op in jedem query in einer grouped_table_op darf nur eine Tabelle erzeugen.

Die "arg"-Elemente des Tabellenvorgangs teilen dem Tabellenvorgang mit, wie er seine Eingabetabellen zu einer Ausgabetabelle verarbeiten muss. Ein arg kann eines von drei Elementen sein:

Ein Tabellenname (table_name), der eine Tabelle benennt oder Teil des Namens einer Tabelle ist, die aus der Cloud Monitoring-Datenbank abgerufen werden soll.
Ein Ausdruck (expr), der eine Formel zum Berechnen eines Werts ist. Dies kann ein statisch bekannter Literalwert sein oder ein Wert, der aus den Spaltenwerten einer oder mehrerer Zeilen aus der Eingabetabelle oder den Tabellen des Tabellenvorgangs berechnet wird.
Eine Zuordnung (map), die beschreibt, wie die Spalten in der Ausgabetabelle eines Tabellenvorgangs berechnet werden. Ein map enthält einen oder mehrere expr, die die Werte der Spalten berechnen.

Tabellennamen

Ein table_name bezeichnet einen überwachten Ressourcentyp, einen Messwerttyp, eine Gruppe oder eine Tabelle. Diese werden in Tabellenvorgängen verwendet, um Tabellen aus der Zeitachsendatenbank zur weiteren Verarbeitung abzurufen.

table_name : name { '::' name } .
name : string | BARE_NAME | ID .

Ein einzelner name bezieht sich auf einen überwachten Ressourcentyp oder Messwerttyp, z. B. den Typ der überwachten Ressource gce_instance oder aws_dynamodb_table oder den Messwerttyp loadbalancing.googleapis.com/http/backend_latencies.

Ein Typ einer überwachten Ressource kann auch mit einem Gruppennamen oder einem Namen der überwachten Ressource gefolgt von :: und einem Gruppennamen benannt werden. Ersteres kann verwendet werden, wenn die Gruppe einen einzelnen Typ für überwachte Ressource angibt und letzteres verwendet wird, wenn die Gruppe dies nicht tut.

Eine gespeicherte Tabelle wird durch den Namen der überwachten Ressource gefolgt von :: und einen Namen für den Messwerttyp angegeben. Beispiel: gce_instance :: loadbalancing.googleapis.com/http/backend_latencies

Ausdrücke

Ein Ausdruck (expr) ist eine Formel zur Berechnung eines Werts. Er wird als Argument für einen Tabellenvorgang verwendet und hilft bei der Beschreibung der Transformation, die der Tabellenvorgang für die Eingabetabelle oder -tabellen durchführt. Ein expr kann ein Literalausdruck oder ein dynamischer Ausdruck sein.

Ist ein expr literal, so besteht er nur aus Literalwerten und einfachen Funktionsaufrufen, deren Argumente Literalwerte sind. Der Wert eines solchen Ausdrucks wird bestimmt, bevor die Abfrage auf Tabellen angewendet wird.

Wenn ein expr dynamisch ist, kann sie Verweise auf Tabellenspalten enthalten und zur Berechnung eines Werts aus einer oder mehreren Zeilen aus der Eingabetabelle verwendet werden. Es gibt drei Arten von dynamischen Ausdrücken:

Wertausdruck Ein Wertausdruck erzeugt einen Wert für jede Eingabetabellenzeile, auf die er angewendet wird. Sie kann Verweise auf Tabellenspalten enthalten. Bei der Auswertung für eine Eingabezeile werden diese Verweise auf die entsprechenden Spaltenwerte in der Zeile ausgewertet.
Aggregationsausdruck Ein Aggregationsausdruck erzeugt einen Wert für eine Reihe von Eingabetabellenzeilen. Es gliedert sich in drei Teile:
- Einen oder mehrere Wertausdrücke, die einzeln auf jede Eingabezeile angewendet werden, um einen Wert für jede Zeile zu erzeugen. Diese Wertausdrücke sind Argumente für Aggregationsfunktionen.
- Eine oder mehrere Aggregationsfunktionen, die eine Sammlung von Eingabewerten, die durch den/die Wertausdruck(e) erzeugt werden, nehmen und sie auf einen einzigen resultierenden Wert reduzieren.
- Einen äußeren Ausdruck über die Aggregationsfunktionen, der die Werte annimmt, die sich aus den Aggregationsfunktionen ergeben, und den Wert des Ausdrucks als Ganzes erzeugt.
Im Aggregationsausdruck sum(if(status >= 500, val(), 0)) / sum(val()) sind die Teile beispielsweise so:
- Die Wertausdrücke sind if(status >= 500, val(), 0) und val(). Diese werden auf jede Eingabezeile angewendet, um zwei Sammlungen von Werten zu erstellen.
- Die Aggregatoren sind die zwei sum-Funktionsaufrufe. Jeder Funktionsaufruf nimmt die Sammlungen von Werten als Eingabe an, die vom Wertausdruck erzeugt wurden, der sein Argument ist.
- Der Außenausdruck ist der Divisionsoperator (/), der auf die endgültige Ausgabe jeder der sum-Aggregationsfunktionen angewendet wird, um den Wert des Gesamtausdrucks zu erzeugen.
Ausrichtungsausdruck: Ein Ausrichtungsausdruck besteht aus einem einzelnen Aufruf einer Ausrichtungsfunktion. Die Ausrichtungsfunktion erzeugt einen Ausgabewert aus einer Eingabezeitachse und wird von align verwendet, um eine ausgerichtete Tabelle zu erstellen.

Jeder Ausdruck besteht aus opnd-Elementen (unten definiert), die durch Operatoren verbunden sind.

expr : term { infix_op term } .
term : { prefix_op } opnd .
infix_op : '&&' | '||' | '^'
         | '==' | '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=' | '=~' | '!~'
         | '+' | '-'
         | '*' | '/' | '//' | '%' .
prefix_op : '+' | '-' | '!' .

Die Operatoren verhalten sich wie gewohnt entsprechend ihrer Priorität. In der folgenden Tabelle sind die Operatoren in fünf Gruppen angeordnet. Alle Operatoren in einer Gruppe haben die gleiche Priorität, wobei höhere Gruppen fester gebunden sind. Operatoren derselben Priorität werden von links nach rechts angewendet. Jeder Operator entspricht einer Funktion in der Tabelle, die auf dessen Operanden angewendet wird.

Operator	Funktion	Vorgang
`*` `/` `//` `%`	`mul` `div` `div` `rem`	Multiplikation Division Ganzzahldivision Ganzzahlrest
`+` `-`	`add` `sub`	Addition Subtraktion
`==` `=` `!=` `<>` `<=` `>=` `>` `<` `=~` `!~`	`eq` `ne` `le` `ge` `gt` `lt` `re_full_match` `! re_full_match`	Gleichheitsvergleich Ungleichheitsvergleich Kleiner-als-oder-gleich-Vergleich Größer-als-oder-gleich-Vergleich Größer-als-Vergleich Kleiner-als-Vergleich Regulärer Ausdruck vollständige Übereinstimmung Regulärer Ausdruck keine vollständige Übereinstimmung
`&&`	`and`	Logisch und
`\|\|`	`or`	Logisch oder

Die Präfixoperatoren +, -, und ! entsprechen den unären Funktionen pos, neg und not und werden vor jedem Infix-Operator angewendet.

a < b && a + b + c / -d == 5 entspricht also (a < b) && (((a + b) + (c / (-d))) == 5), der wiederum and(lt(a, b), eq(add(add(a, b), div(c, neg(d))), 5)) entspricht.

Die Operatoren arbeiten mit Operanden (opnd).

opnd : literal | column_meta_name | '_' | '(' expr ')' | call_chain .

literal : NUMBER [ unit ] | string | DURATION | DATE .
unit : STRING
string : STRING { STRING } .

column_meta_name : id { '.' id } .
id : ID | QUOTED_COLUMN .

Jede opnd entspricht einer bestimmten Methode zur Berechnung eines Werts.

literal ist der Wert des angegebenen Literaltokens.
- Auf ein NUMBER-Literal kann ein unit folgen, das die Maßeinheiten des Literalwerts angibt, z. B. 33 'By' für 33 Byte.
- Ein string besteht aus einem oder mehreren STRING-Tokens, die zu einem Stringwert zusammengeführt werden. Daher hat 'a-' 'b' denselben Wert wie 'a-b'.
column_meta_name benennt eine Spalte oder eine virtuelle Metadatenspalte in der Eingabetabelle und wird als Wert dieser Spalte in der Eingabezeile ausgewertet, auf die der Ausdruck angewendet wird.
_ steht für den Standardwert. Dies kann nur als tatsächliches Argument für ein optionales formales Argument angegeben werden.
'(' expr ')' ist ein Ausdruck in Klammern, der nur der Wert von expr ist.
call_chain ist ein oder mehrere verkettete Funktionsaufrufe:

call_chain : [ ID arg_list ] { '.' call } .
arg_list : '(' [ expr { ',' expr } [ ',' ] ] ')' .
call : ID [ arg_list ] .

Jede ID in einer Aufrufkette benennt eine Funktion, die auf null oder mehr Argumente angewendet wird. Die Argumente für einen Funktionsaufruf können aus den Wertspalten der Eingabetabelle, aus dem Ergebnis eines früheren call in der Aufrufkette oder aus dem Wert von expr in einer arg_list stammen.

Wenn die Aufrufkette mit einem ID (und kein . davor) beginnt, werden die Argumente für die aufgerufene Funktion durch expr im folgenden arg_list angegeben.

Beispielsweise wendet add(error_count, 1) die Funktion add auf zwei Argumente an: column_meta_name error_count und literal 1. Dies entspricht error_count + 1.
Wenn ein call_chain mit einem '.' call beginnt, sind die Wertspalten der Eingabetabelle das erste Argument für die aufgerufene Funktion. Wenn call ein arg_list hat, stellt arg_list zusätzliche Argumente bereit.

Beispielsweise würde .div, das auf eine Tabelle mit den Wertspalten num und den angewendet wird, div(num, den) oder nur num / den entsprechen. Der Ausdruck .add(3), der auf eine Tabelle mit einer einzelnen Wertspalte count angewendet wird, entspricht add(count, 3) oder nur count + 3.
Die Funktion, die von einer anderen call als der ersten in einer Aufrufkette aufgerufen wird, akzeptiert als erstes Argument die Ausgabe der zuvor aufgerufenen Funktion in der Aufrufkette. Wenn call ein arg_list hat, stellt arg_list zusätzliche Argumente bereit.

Beispiel: .mul(3).div(4) angewandt auf eine Tabelle mit einer Spalte mit einer einzelnen Wertspalte error_count entspricht div(.mul(3), 4) was entspricht div(mul(error_count, 3), 4) und dies wiederum error_count * 3 / 4 oder (error_count * 3) / 4.

Beachten Sie, dass die Spalten für die Endzeit und die Startzeit in einer Tabelle keine Spaltennamen haben. Der Wert der Zeitspalten wird mit den Funktionen end und start aufgerufen.

Maps

Eine map berechnet Werte für Spalten in einer Ausgabezeile und gibt ihnen Namen. Je nachdem, wo die map verwendet wird, handelt es sich entweder um eine Zeitachsenkennzeichnungs-map, die die Zeitachsenkennzeichnungsspalten der Ausgabezeile berechnet, oder um eine Wert-map, die die Wertspalten der Ausgabezeile berechnet.

map : [ modifier ] '[' [ maplet { ',' maplet } ] ']' .
modifier : ID .
maplet : [ column_name ':' ] expr .
column_name : ID | QUOTED_COLUMN .

Jeder expr im maplet berechnet den Wert einer Ausgabespalte und column_name gibt den Namen der Spalte an. Wenn kein column_name angegeben ist, wird einer aus dem expr konstruiert. Wenn expr nur der Name einer Eingabespalte ist, ist column_name identisch. Wenn Funktionen angewendet werden, werden diese dem Namen hinzugefügt. Zum Beispiel würde sum(error_count / 3) den Namen error_count_div_sum erhalten.

Die von map berechneten Ausgabespalten (Zeitachsenkennzeichnung oder -wert) stammen aus den maplet s in map und aus den entsprechenden Spalten (Zeitachsenkennzeichnung oder -wert) in der Eingabetabelle. Wie dies umgesetzt wird, hängt von modifier ab:

Kein modifier Die entsprechenden Spalten der Ausgabezeile bestehen aus genau den Spalten, die durch ein maplet im map angegeben werden. Der Name der Spalte wird entweder explizit durch ein ID oder QUOTED_COLUMN angegeben oder aus der Form des expr abgeleitet. Der Wert der Spalte in der Ausgabezeile ist der Wert von expr.

Jede maplet muss einen (expliziten oder abgeleiteten) Spaltennamen haben, der unter allen Spalten in der Ausgabetabelle eindeutig ist.

Beispiel: Anwendung von [ratio: num/den] als Wertspalte map in eine Tabelle mit Wertspalten num und den würde zu einer Ausgabetabelle mit einer Wertspalte ratio führen, wobei der ratio-Spaltenwert das Verhältnis der beiden Eingabespalten ist.

Wenn Sie [zone] als Zeitachsenkennzeichnung map auf eine Tabelle mit den Zeitachsenkennzeichnungsspalten project_id, zone und instance anwenden, würde dies zu einer Tabelle mit nur einer zone-Zeitachsenkennzeichnungsspalte führen, deren Wert mit der Eingabetabellenspalte zone identisch ist.
add Alle Spalten der entsprechenden Art (Zeitachsenkennzeichnung oder -wert) der Eingabezeile sind in der Ausgabezeile enthalten. Darüber hinaus gibt es für jedes maplet in map eine zusätzliche Ausgabespalte, deren Name und Wert von maplet angegeben werden.

Jede maplet muss einen (expliziten oder abgeleiteten) Spaltennamen haben, der unter allen Spalten in der Ausgabetabelle eindeutig ist.

Wenn Sie beispielsweise add[ratio: num/den] als Wert map auf eine Tabelle mit den Wertspalten num und den anwenden, erhalten Sie eine Ausgabetabelle mit den Wertspalten num, den und ratio, wobei der Spaltenwert ratio dem Verhältnis der beiden anderen Spalten entspricht.
update Alle Spalten der entsprechenden Art (Zeitachsenkennzeichnung oder -wert) der Eingabezeile, deren Spaltenname nicht der Spalte einer maplet in map entspricht, sind in der Ausgabezeile enthalten. Darüber hinaus gibt es für jedes maplet in map eine zusätzliche Ausgabespalte, deren Name und Wert von maplet angegeben werden.

Jede maplet muss einen (expliziten oder abgeleiteten) Spaltennamen haben, der unter allen Spalten in der Ausgabetabelle eindeutig ist. Es kann eine Spalte der entsprechenden Art in der Eingabe benennen, die es ersetzt.

Das folgende Beispiel zeigt die Zeitachsenkennzeichnung map:
```
  update[job: re_extract(job, '[^-]*-(.*)', r'\1'),
         kind: re_extract(job, '([^-]*)-.*', r'\1')]
```
Bei Verwendung in einer Tabelle mit den Zeitachsenkennzeichnungsspalten user, job und zone würde zu einer Ausgabetabelle mit der Zeitachsenkennzeichnungsspalte user, job, zone und kind führen.
drop Jedes maplet muss aus einem expr bestehen, das nur der Name einer Eingabespalte des entsprechenden Typs ist. Die Ausgabespalten bestehen aus allen Eingabespalten der entsprechenden Art mit Ausnahme der Spalten, die in einem expr im maplet benannt sind.

Jedes maplet darf kein column_name haben und expr muss in der Eingabetabelle einfach eine Spalte des entsprechenden Typs benennen.

Wenn Sie beispielsweise drop [job, user] als Zeitachsenkennzeichnung map auf eine Tabelle mit den Zeitachsenkennzeichnungsspalten user, job und zone anwenden, erhalten Sie eine Ausgabetabelle mit der Zeitachsenkennzeichnungsspalte zone.
ignore Jede maplet muss aus einem expr bestehen, das nur ein Spaltenname ist. Wenn der Name der Name einer Eingabespalte der entsprechenden Art ist, erscheint diese Spalte nicht in den Ausgabespalten. Wenn der Spaltenname maplet keine Eingabetabellenspalte der entsprechenden Art benennt, hat maplet keine Auswirkung. Daher bestehen die Ausgabespalten aus allen Eingabespalten der entsprechenden Art, mit Ausnahme derer, die in expr in maplet benannt sind.

Jede maplet darf keinen column_name haben und der expr muss einfach ein Spaltenname, aber nicht der Name einer Spalte in der Eingabetabelle sein. Wenn maplet keine Spalte in der Eingabetabelle benennt, wird sie ignoriert.

Wenn Sie beispielsweise ignore [job, instance] als Zeitachsenkennzeichnung map auf eine Tabelle mit den Zeitachsenkennzeichnungsspalten user, job und zone anwenden, erhalten Sie eine Ausgabetabelle mit der Zeitachsenkennzeichnungsspalte user und zone (wobei das Maplet instance ignoriert wird).
rename Jede maplet muss eine explizite column_name haben und einen expr enthalten, die nur auf eine Spalte der entsprechenden Art in der Eingabetabelle verweist. Die Ausgabespalten sind alle Spalten der entsprechenden Art in der Eingabetabelle, wenn jedoch in einer maplet auf einen neuen Namen verwiesen wird, der von column_name in maplet angegeben wird.

Die column_name in jedem maplet muss unter den Spaltennamen der Ausgabetabelle eindeutig sein.

Beispiel: Anwendung von rename[numerator : num, denominator : den] als Wertspalte map in eine Eingabetabelle mit Wertspalten num, den, und ratio würde zu einer Ausgabetabelle mit Wertspalten numerator, denominator, und ratio führen.

Maßeinheiten

Mit jedem numerischen Wert (Int, Double und Distribution) kann eine Maßeinheit verknüpft werden, die die von diesem Wert verwendete Maßeinheit angibt. Einheiten werden durch Strings dargestellt, die einer Teilmenge des Unified Code for Units of Measure (UCUM) folgen. Beispielsweise hat ein Wert, der die Anzahl von Byte angibt, die Einheit "By" und ein anderer Wert, der die Rate von übertragenen Byte angibt, die Einheit "By/s".

Einheiten werden an die Tabellenspalten angehängt, die durch Tabellenvorgänge erstellt werden, und an die Werte von Ausdrücken. Sie sind statisch mit der Spalte oder dem Ausdruck verknüpft, wie der Typ. Jeder Spalte oder jedem Ausdruck mit einem numerischen Typ können Einheiten zugeordnet sein, dies muss jedoch nicht sein.

Die Einheiten, die an Spalten in Tabellen angehängt sind, stammen aus diesen Quellen:

Messwertdeskriptoren können die Einheiten für den Wert eines Messwerts angeben. Diese finden sich in der Dokumentation zu den Messwerten (z. B. hier). Die Wertspalten der von Tabellenvorgängen vom Typ fetch und metric erstellten Tabellen nutzen die durch den Messwertdeskriptor angegebenen Einheiten.
Ausgabetabellenspalten, die nur eine Kopie der Spalte aus der Eingabetabelle sind, haben dieselben Einheiten wie die Eingabetabellenspalte. Daher werden die Einheiten für Spalten der Eingabetabelle durch den Tabellenvorgang filter beispielsweise nicht geändert und an die Ausgabe übergeben.
Der Tabellenvorgang union kombiniert mehrere Tabellen zu einer Tabelle, wobei alle Tabellen dieselben Spalten haben müssen. Wertspalten in Eingabetabellen müssen entweder keine Einheiten zugeordnet sein, oder Einheiten, die den Einheiten entsprechen, die dieser Spalte eventuell in den anderen Eingabetabellen zugeordnet sind. Werden in einer der Eingabetabellen Einheiten für eine Spalte angegeben, so enthält diese Spalte diese Einheiten der Ausgabetabelle. Wurde für keine der Eingabetabellen Einheiten für eine Spalte angegeben, so enthält diese Spalte keine Einheiten in der Ausgabe.
Bei Tabellenvorgängen mit einem expr, der einen Spaltenwert einer Ausgabetabelle berechnet, sind bei den Einheiten in der Ausgabespalte wie unten beschrieben die Einheiten an jenen expr angehängt.

Die an einen expr angehängten Einheiten hängen von der Form von expr ab:

Literalwerte allein haben keine Einheiten. Numerischen Literalen (Int oder Double) hingegen können Einheiten zugewiesen werden, indem Sie dem Wert mit einem String folgen, der die Einheit angibt. Dementsprechend ist 3 "By" ein expr mit dem Wert 3, dessen Typ Int ist mit der Einheit Byte (By).
Spaltenverweisausdrücke rufen Einheiten aus der benannten Spalte in der Eingabetabelle ab, wenn sie Einheiten enthält.
Funktionen und Operatoren leiten die Maßeinheit für ihre Ausgabewerte von der Einheit der Eingabewerte ab. Hat also amount die Einheit By und time die Einheit s, dann hat amount / time die Einheit By/s. Bei Funktionen, die zwei numerische Argumente aufnehmen, müssen in der Regel beide Argumente oder keines der Argumente Einheiten nutzen. In den Dokumentationen der einzelnen Funktionen wird die Behandlung von Maßeinheiten durch die jeweilige Funktion beschrieben.

Viele Funktionen machen den Einheitenabgleich erforderlich. Beispiel: add macht es erforderlich, dass beide Operanden, wenn sie Einheiten haben, dieselbe Einheit nutzen. Diese Anforderungen werden in den Dokumentationen der jeweiligen Funktion beschrieben.
Die Funktionen scale und cast_units haben einheitenspezifische Funktionen.

Die Funktion scale multiplizieren einen Wert mit einer Einheit gemäß eines Skalierungsfaktors, der diesen in einen Wert mit einer anderen Einheit konvertiert. Für expr ev mit der Einheit "KiBy" (Kibi-Byte) führt scale(ev, "By") dazu, dass ev mit 1024 multipliziert wird. Die Ergebniseinheit ist dann By. Dies entspricht ev * 1024 'By/KiBy'.

Die Funktion cast_units gibt ihr Argument mit einer bestimmten Einheit zurück, unabhängig von der ursprünglichen Einheit des Arguments, falls vorhanden. Somit führt cast_units(ev, 'By/s') zum Wert ev, der unverändert, aber mit der Einheit By/s ist

Die Teilmenge der von MQL unterstützten UCUM-Einheiten wird durch Stringwerte angegeben, die dieser Grammatik folgen:

digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
exponent : [ '+' | '-' ] { digit }
simple_unit : [ PREFIX_SYMBOL ] ATOM_SYMBOL
annotatable : '10^' exponent | simple_unit
component : annotatable [ annotation ] | '1'
annotation : “{” ANNOTATION-STRING “}” | annotatable | annotation
unit : component { '.' component } { '/' component }

Eine simple_unit gibt eine Einheit an, die durch eine ATOM_SYMBOL angegeben wird und optional als Präfix einen von einem PREFIX_SYMBOL angegebenen Skalierungsfaktor.

Ein ATOM_SYMBOL gibt eine grundlegende Maßeinheit an:

text	Bedeutung
s	Sekunde
Min.	Minute (60 Sekunden)
h	Stunde (60 Minuten)
d	Tag, (24 Stunden)
Wo.	Woche (7 Tage)
Bit	Bit
Von	Byte (8 Bit)
%	10^-2 (Verhältnis ohne Dimension skaliert in %)
m	Meter
g	Gramm
K	Kelvin
C	Coulomb
Hz	Hertz (1/s)
J	Joule (kg.m.m/s/s)
W	Watt (kg.m.m/s/s/s) (J/s)
A	Ampere (C/s)
V	Volt (kg.m.m/s/s/C) (J/C)

Ein PREFIX_SYMBOL gibt einen Skalierungsfaktor für die grundlegende Einheit an, der es vorangestellt wird:

text	Bedeutung	profitieren
K	Kilo	10^3
M	Mega	10^6
G	Giga	10^9
T	Tera	10^12
P	Peta	10^15
E	Exa	10^18
Z	Zetta	10^21
Y	Yotta	10^24
m	Milli	10^-3
u	micro	10^-6
n	Nano	10^-9
p	Pico	10^-12
f	Femto	10^-15
a	Atto	10^-18
z	Zepto	10^-21
y	Yocto	10^-24
Ki	Kibi	2^10
Mi	Mebi	2^20
Gi	Gibi	2^30
Ti	Tebi	2^40
Pi	Pebi	2^50

Eine Einheit ohne Dimension kann als 1 oder als Potenz von 10 (10^ exponent wie 10^2) angegeben werden. Die Einheit 1 ist die Einheit, die den meisten Zählermesswerten zugewiesen wird. Das dimensionslose Verhältnis, das auf die Prozentzahl % skaliert wird, wird ebenfalls unterstützt. Daher haben 10^-2 und % dieselben Einheiten. Anders ausgedrückt: Wenn Sie einem Prozentwert 3 hinzufügen, ist dies dasselbe wie wenn Sie dem entsprechenden Verhältnis 0,03 hinzufügen. exponent ist auf einen Bereich von -128 bis 127 beschränkt.

Ein annotation ist ein Kommentar, der an einen annotatable (simple_unit oder Potenz von 10) angehängt werden kann, und ändert die Bedeutung der Einheit nicht. Eine Anmerkung, die keiner Einheit zugeordnet ist, wird so behandelt, als wäre sie der Einheit 1 zugewiesen. Daher entspricht {queries}/s 1/s, wobei die Einheit 1 mit {queries} versehen ist.

Ein Einheitenstring kann aus mehreren component-Strings bestehen, die durch . oder / verbunden sind. Der .-Connector gibt die Multiplikation der Einheiten und der /-Connector die Division an. Die Multiplikation und Division werden von links nach rechts angewendet. Für die Teilmenge der von MQL unterstützten UCUM-Einheiten müssen alle Divisionsconnectors nach den Multiplikationsconnectors stehen. Dadurch vermeiden Sie das Problem, die Einheiten der Beschleunigung als m/s.s zu Schreiben, wenn m/s/s beabsichtigt ist. Bei UCUM-Einheiten ist m/s.s gleich m.s/s oder nur m.

Zwei Einheitenstrings sind, unabhängig von Anmerkungen, äquivalent, wenn beide dieselbe Dimension und Skalierung haben. Dimension und Skalierung werden wie üblich bestimmt:

Jeder component ist entweder dimensionsfrei oder hat eine Dimension, die eine Kombination aus Zeit, Länge, Daten, Masse und Ladung ist. Beispiel: bit und By haben die Dimension Daten. Um die Dimensionen eines Einheitsstrings zu ermitteln wird jede Anmerkungstabelle in ihre Dimension konvertiert. Diese wird dann gemäß dem Einheitenstring multipliziert und geteilt. Dimensionen, die in Zähler und Nenner auftauchen, werden dabei weggekürzt. Das heißt, b.h/s (Bit-Stunde pro Sekunde) hat die DimensionDaten mal Zeit, geteilt durch Zeit. Die Dimension Zeit wird weggekürzt, es verbleibt die Dimension Daten.
Jede Annotierbare hat eine Skalierung relativ zu den Grundeinheiten ihrer Dimension. Beispiel: h (Stunde) hat die Dimension Zeit mit der Grundeinheit s und einem Skalierungsfaktor von 3.600 (jede Stunde beträgt 3.600 Sekunden). Der Skalierungsfaktor eines Einheitsstrings ist die Kombination aus den Skalierungsfaktoren jedes component, kombiniert durch Multiplikation und Division.

Numerische Literale können Einheiten zugewiesen werden, wobei dem Wert der String für die gewünschte Maßeinheit angehängt wird. 3 "m/s" ist also der Wert 3 mit der Einheit m/s, 10.8 "km/h" stellt die gleiche Geschwindigkeit wie der Wert 10.8 mit der Einheit km/h dar.

Ein Wert mit einer Einheit kann mithilfe der Funktion scale skaliert werden, sodass er eine andere Einheit mit derselben Dimension verwendet. Zum Beispiel haben MiBy und By die Dimension Daten mit dem Skalierungsfaktor 8*1024 bzw. 8 (relativ zur Basiseinheit der Dimension Daten, die bit ist). Ein Wert x mit der Einheit MiBy kann durch den Ausdruck scale(x, "By") auf einen Wert mit der Einheit By skaliert werden. Dadurch wird x mit 1.024 multipliziert und ein Wert mit der Einheit By wird ausgegeben. Dies entspricht dem Ausdruck x * 1024 "By/MiBy", size * 1024 "By/MiBy" und die Einheit des resultierenden Ausdrucks ist MiBy.By/MiBy oder einfach By.

Die Funktion scale prüft, ob die angefragte Einheit dieselbe Dimension wie die Einheit des skalierten Werts hat.

Wenn size eine Spalte ist, deren Wert die Einheit "KiBy" hat, ist der Ausdruck scale(size, "By") mit size * 1024 "By/KiBy" identisch und die Einheit des resultierenden Ausdrucks ist MiBy.By/MiBy oder einfach By.

Es gibt eine begrenzte Anzahl an Fällen, in denen MQL die Einheiten für einen Wert automatisch anpasst oder bereitstellt.

Für eine Funktion f, die zwei Argumente mit äquivalenten Einheiten (add, sub, beliebiger der numerischen Vergleichsoperatoren, if und or_else) erfordert , kann eines der Argumente ein Aufruf der Funktion scale ohne das Argument der zweiten Einheit sein. Wenn die Einheit des anderen Arguments von f dieselbe Dimension wie die Einheit des Arguments für die Funktion scale hat, wird das zweite Argument der Funktion scale automatisch auf die Einheiten des anderen Arguments von f gesetzt. Dadurch werden die Einheiten zweier Argumente von f äquivalent und f kann ausgeführt werden.

Beispiel: Der Operator + verlangt, dass seine Argumente äquivalente Einheiten nutzen, da es nicht sinnvoll ist, zwei Zahlen mit unterschiedlichen Einheiten zu addieren. Wenn cache_size die Einheit By und heap_size die Einheit MiBy nutzt, entspricht der Ausdruck scale(cache_size) + heap_size dem Ausdruck scale(cache_size, "MiBy") + heap_size.
Bei allen Vergleichsfunktionen gilt: Wenn ein Argument ein Literal mit einer Einheit ist, das die gleiche Dimension, aber eine andere Skalierung als das andere Argument hat, wird das Literal skaliert, um für beide die gleiche Skalierung zu erreichen.

Wenn "cache_size" beispielsweise die Einheit By hat, entspricht der Ausdruck cache_size < 3 "KiBy" dem Ausdruck cache_size < 3072 "By". Beachten Sie, dass dies nicht dasselbe ist wie cache_size < scale(3 "KiBy", "By"), wenn cache_size vom Typ Int ist, weil scale das Ergebnis in den Typ Double umwandelt. Dadurch könnte der Vergleich ungenau werden. Bei der ganzzahligen Skalierung wird in diesem Fall eine ordnungsgemäße Rundung und Handhabung des Rests für den jeweiligen Vergleich berücksichtigt.
Für das Argument von mul oder den Divisor von div wird einem Literal ohne Einheit die Einheit "1" zugewiesen. Dabei werden Skalierungsvorgänge berücksichtigt, die keine Einheiten ändern sollen, z. B. die Frage, was wäre, wenn sich die Rate verdoppelt. Um Einheiten zu ändern, am besten verwenden Sie scale, um automatisch den richtigen Skalierungsfaktor für die Konversion auszuwählen.

Einheitenfehler werden bei der Bewertung einer Abfrage als Warnungen behandelt, entsprechend liefert die Abfrage weiterhin Ergebnisse. Beim Definieren einer Benachrichtigung werden Einheitenfehler als echte Fehler behandelt und verhindern, dass die Benachrichtigung definiert wird.

Beachten Sie: Dauer und Datum sind KEINE numerische Typen und nutzen keine Einheiten. Der Dauer-Wert 60s ist eine nicht-numerische Dauer und entspricht genau der Dauer von 1m oder60000ms. Der Ausdruck 60s == 60000ms ist gültig und wahr.

Ein numerischer Wert mit einer Zeiteinheit verhält sich anders. Die Zahlen 3 'min' und 180 's' sind zwei verschiedene numerische Werte (3 und 180) mit unterschiedlichen Einheiten. Ohne Skalierung können sie nicht verglichen werden.

Die Funktion scale konvertiert die Werte Dauer und Datum in Double-Werte mit Einheiten. Beispiel: scale(60s, "min"), scale(1m, "min") und scale(60000ms, "min") geben alle den Doppelwert 1.0 mit Einheit min zurück.

Kurzformen für Tabellenvorgänge

Eine Kurzform ("shortcut") ist eine einfachere Methode zur Angabe eines grundlegenden Tabellenvorgangs.

shortcut_table_op : shortcut { ',' arg } .
shortcut : table_name | '(' expr ')' | map | DURATION .

Es gibt verschiedene Arten von Kurzformen für Tabellenvorgänge, wobei jede Art einen bestimmten Typ von grundlegendem Tabellenvorgang bezeichnet:

Eine Kurzform der Art "Funktionshochstufung" sieht wie ein normaler Tabellenvorgang aus, der Tabellenvorgang beginnt jedoch mit einer ID, die eine Funktion anstelle eines Tabellenvorgangs angibt, und die folgenden arg-Elemente (alle in Form von expr) sind die Argumente für die Funktion.

Die Funktion wird hochgestuft, indem ein Tabellenvorgang angegeben wird, für den die Funktion als Argument fungiert. Die Wertspalte oder -spalten der Eingabetabelle werden zu den ersten Argumenten für die Funktion, als ob ihr ein .-Operator vorangegangen wäre. Die spezifischen Hochstufungen lauten so:
- Eine gewöhnliche Funktion wird zum Argument eines value-Tabellenvorgangs, der die einzelne Wertspalte der Ausgabetabelle berechnet.
  
  Beispiel: | add 3 ist eine Verknüpfung für value [.add(3)] und | div ist eine Verknüpfung für | value [.div].
- Eine Aggregatfunktion wird zum zweiten Argument eines group_by-Tabellenvorgangs, dessen erstes Argument das leere map ([ ]) ist. Somit berechnet die Funktion die einzelne Wertspalte einer Ausgabetabelle ohne Zeitachsenkennzeichnungsspalten (eine Tabelle mit einer einzelnen Zeitachse).
  
  | min ist beispielsweise ein Kürzel für | group_by [], [.min].
- Eine Ausrichtungsfunktion wird zum Argument für einen align-Tabellenvorgang und führt somit die festgelegte Art der Ausrichtung auf die Zeitachse der Eingabetabelle aus.
  
  Beispielsweise ist | delta 10m eine Verknüpfung für den Tabellenvorgang | align [.delta(10m)].
Eine Namensverknüpfung beginnt mit einem table_name die als Argument für den resource, metric, oder fetch-Tabellenvorgang verwendet wird, je nachdem, welche Art von Dingen table_name benennt.

Beispielsweise ist | gce_instance eine Verknüpfung für den Tabellenvorgang | resource gce_instance und | gce_instance :: compute/instance/cpu/usage_time ist eine Verknüpfung für | fetch gce_instance :: compute/instance/cpu/usage_time.
Eine Filterverknüpfung besteht aus einem expr in Klammern, das zum Prädikat in einem filter-Tabellenvorgang wird.

Beispielsweise ist | (job == 'search') eine Abkürzung für | filter job == 'search'.
Eine Verknüpfung mit einer Gruppierung beginnt mit einem map, das zum ersten Argument für einen group_by-Tabellenvorgang wird. Darauf kann ein arg folgen, der ein map ist, das die Aggregation beschreibt, die die Wertspalten der Ausgabetabelle berechnet.

Beispielsweise ist | [zone] eine Abkürzung für | group_by [zone].
Eine Windowing-Verknüpfung beginnt mit einem DURATION, das das erste Argument für einen group_by-Tabellenvorgang ist. Darauf muss ein arg folgen, der ein map ist. Damit wird die Aggregation beschrieben, die die Wertspalten der Ausgabetabelle berechnet.

Beispielsweise ist | 10m, [.sum] eine Abkürzung für | group_by 10m, [.sum].
Eine Kurzform der Art "Dauer" beginnt mit einer DURATION ohne folgendes arg. Sie wird zu einem for-Tabellenvorgang und gibt die gesamte zeitliche Ausdehnung des Abfragevorgangs an.

| 10m ist beispielsweise ein Kürzel für | for 10m.

Tabellenvorgänge und Funktionsbeschreibungen

Jeder Tabellenvorgang und jede Funktionsbeschreibung der Monitoring-Abfragesprache beginnt mit einer Dokumentationssignatur, die die Tabelleneingaben (für Tabellenvorgänge) und die Argumenttypen angibt, die für den Tabellenvorgang oder die Tabellenfunktion angegeben werden können. In diesem Abschnitt wird das Format dieser Signaturen beschrieben.

Beachten Sie, dass diese Signaturen NICHT Teil der Monitoring-Abfragesprache selbst sind. Sie werden zur Beschreibung der Monitoring-Abfragesprache verwendet.

Eine Signatur für Tabellenvorgänge beginnt optional mit einem Typ, der die Eingabetabellen für die Tabellenvorgänge beschreibt, gefolgt vom Namen des Tabellenvorgangs, gefolgt von einer Argumentliste, die die gültigen Argumente für den Tabellenvorgang beschreibt. Beispiel: Die Signatur des Tabellenvorgangs pick:

Tabelle | pick lit-Int, [ TSIDSel ], [ Windowed(Num) ]

Dieser Tabellenvorgang erfordert eine Table als Eingabe (der häufigste Fall) und hat drei potenzielle Argumente, die durch lit-Int , [TSIDSel ] und [Windowed(Num) ] beschrieben werden.

Die Eingabetabelle und | sind optional. Wenn Sie den Tabellenvorgang nicht angeben, nimmt keine Eingabetabelle an. Die Eingabetabellenspezifikation ist eine der folgenden:

Table: Die Eingabe für den Tabellenvorgang ist eine einzelne Tabelle.
Table++: Der Tabellenvorgang nimmt zwei oder mehr Tabellen als Eingabe an.
Ressource Der Tabellenvorgang nimmt eine Sammlung von Tabellen an, die durch einen Typ einer überwachten Ressource angegeben sind (alle Tabellen, die Zeitachsen enthalten, deren Typ einen bestimmten Typ von überwachten Ressourcen enthält).
ResourceOrTable Entweder Tabelle oder Ressource ist als Eingabe zulässig.

Jeder Argumentdeskriptor in der Argumentliste nach dem Namen des Tabellenvorgangs besteht aus folgenden Teilen:

Er kann in [ ] eingeschlossen werden. In diesem Fall ist es optional und das tatsächliche Argument kann als _ angegeben oder weggelassen werden, wenn das tatsächliche Argument nach allen explizit angegebenen Argumenten positioniert wird.
Er kann das Präfix lit- haben, das angibt, dass der Argumentwert ein konstanter Wert sein muss, bevor wir die Abfrage auswerten.
Er hat immer den Namen eines Werttyps oder einer Typklasse (siehe unten), die den zulässigen Typ des tatsächlichen Arguments beschreibt.
Sie kann ein Suffix haben, das eine Zeitachsenart angibt, die die Zeitachsenart des Eingabewerts einschränkt.

Der Name des Argumentdeskriptortyps kann einer der tatsächlich hier beschriebenen Typen sein: Bool, Int, Double, Verteilung, String, Dauer oder Datum. In diesem Fall muss das tatsächliche Argument ein Ausdruck desselben Typs sein.

Im Folgenden wird angegeben, dass das tatsächliche Argument ein table_name sein muss, das einen Messwert, eine überwachte Ressource, oder Tabelle benennt:

MetricName
ResourceName
TableName

Ein Argumentdeskriptor kann eine Kategorie benennen, die angibt, dass das tatsächliche Argument ein Ausdruck eines der verschiedenen Typen sein kann:

Num: Entweder Int oder Double.
Summable Werttypen, die addiert werden können: Int, Double oder Verteilung.
Vergleichbar: Vergleichbare Werttypen: Int, Double, String, Bool, Dauer, Datum.
ColumnValue: Typen, die gültige Spaltenwerte sind: Int, Double, String, Bool oder Verteilung.
Windowed(Num) A Num, möglicherweise annotiert von within-, ago- oder bottom-Funktionen.
WindowDuration Eine Dauer, möglicherweise mit Anmerkungen von window oder sliding versehen.
BucketSpecification Eine Bucket-Spezifikation für eine Verteilung.

Ein Tabellenvorgang kann ein map-Argument erfordern, das die Zeitachsen-ID-Spalten oder Wertspalten der Ausgabezeile angibt. Dies wird durch eine der folgenden Optionen angezeigt:

RowToTSID: Eine Zuordnung, die die Zeitachsenkennzeichnungsspalten der Ausgabetabelle beschreibt
TSIDSel: Eine Zuordnung, die die Zeitachsenkennzeichnungs-Spalten angibt, die beibehalten werden sollen Jede maplet im map muss nur aus einem expr bestehen, der eine Spalte benennt (ID oder column_name). Beispiel: [zone, name] bewirkt, dass die Ausgabespalten nur aus den Eingabe-Zeitachsenspalten zone und name bestehen, wobei alle anderen Eingabespalten gelöscht werden.
RowToVal: Eine Zuordnung, die die Wertspalten der Ausgabetabelle beschreibt. Wenn ein Nicht-Zuordnungnsausdruck als echtes Argument angegeben wird, wird er zu einer Zuordnung mit einem einzelnen Element mit diesem Ausdruck hochgestuft.
RowSetToVal: Eine Zuordnung, die die Wertspalten der Ausgabetabelle durch Aggregation beschreibt Wenn ein Nicht-Zuordnungnsausdruck als echtes Argument angegeben wird, wird er zu einer Zuordnung mit einem einzelnen Element mit diesem Ausdruck hochgestuft.
DefaultColumns Eine Zuordnung, die Standardwertspalten für ein outer_join beschreibt. Wenn ein Nicht-Zuordnungnsausdruck als echtes Argument angegeben wird, wird er zu einer Zuordnung mit einem einzelnen Element mit diesem Ausdruck hochgestuft.

Eine Funktionssignatur beginnt mit dem Namen der Funktion, gefolgt von einer in Klammern gesetzten Liste mit den gültigen Argumenten für die Funktion, gefolgt von einem Rückgabetyp, der den von der Funktion zurückgegebenen Wert beschreibt. Beispiel: Die Signatur der Funktion fraction_less_than lautet:

fraction_less_than(Summable, lit-Num) → Double

Diese Funktion verwendet zwei durch Summable und Lit-Num beschriebene Argumente und gibt einen Wert vom Typ Double zurück. Die Argumentliste enthält dieselben Elemente, die oben für Tabellenvorgänge beschrieben wurden. Der Rückgabetyp kann ein bestimmter Werttyp sein, der angibt, dass der zurückgegebene Wert diesen Typ hat, oder einer der folgenden Werte:

Num - Wenn eines der Argumente der Funktion Double ist, dann Double, andernfalls Int.
ColumnValue - Derselbe Typ wie das erste tatsächliche Argument für die Funktion.
LastArgType - Derselbe Typ wie das letzte tatsächliche Argument für die Funktion.
Windowed() - Derselbe Typ wie das tatsächliche Argument Windowed, annotiert mit dem Typ Windowed. (Wenn das tatsächliche Argument von Windowed der Typ Int ist, ist der Rückgabetyp Windowed(Int). (Siehe within- , ago- oder bottom-Funktionen.)

Ein Funktionsargument-Deskriptor oder -Rückgabetyp kann einen Indikator haben, der die Zeitachsenart des Arguments oder Ergebnisses steuert. Diese werden als eines der folgenden Suffixe für den Typ angezeigt:

.Cumulative, .Delta oder .Gauge geben an, dass das tatsächliche Argument den angegebenen Zeitachsentyp haben muss.
.CumulativeOK bedeutet, dass ein Argument kumulativ sein kann.
.FirstArgKind bedeutet nur für Rückgabetypen die gleiche Zeitachse, die das erste Argument für die Funktion hat.

Wenn ein Argument kein Zeitachsentypsuffix hat, muss das Argument ein Zeitachsentyp Gauge oder Delta sein. Wenn ein Rückgabetyp kein Zeitachsentypsuffix hat, ist es Gauge.

Eine Funktionssignatur kann auch einen oder mehrere der folgenden Hinweise enthalten:

(implizite Zeileneingabe) gibt an, dass die Funktion die gesamte Zeile als implizite Eingabe nutzt. Die Funktion hash_tsid erzeugt beispielsweise einen Hash der Zeitachsenkennzeichnungs-Spalten der Eingabezeile, übernimmt diese Spaltenwerte jedoch nicht als explizite Argumente.
(nur temporär) Wird für die Signatur von Aggregationsfunktionen verwendet, um anzugeben, dass die Funktionssignatur nur bei einer temporären Aggregation gilt. Ansonsten gelten andere Signaturen für die Funktion. Beachten Sie, dass sowohl die zeitliche als auch die räumliche Aggregation im selben Tabellenvorgang durchgeführt wird.
(nur temporär gleitend) Wird für die Signatur von Aggregationsfunktionen verwendet, um anzugeben, dass die Funktionssignatur nur bei einer gleitenden temporären Aggregation gilt. Ansonsten gelten andere Signaturen für die Funktion. Beachten Sie, dass sowohl die gleitende zeitliche als auch die räumliche Aggregation im selben Tabellenvorgang durchgeführt wird.

Tabellenvorgänge

In diesem Abschnitt werden alle grundlegenden Tabellenvorgänge in der Monitoring-Abfragesprache beschrieben.

Abrufen
- fetch Erstellt eine Tabelle aus der Datenbank.
- metric Erstellt die Tabelle für einen bestimmten Messwerttyp aus einer Reihe von Tabellen.
- fetch_cumulative Erstellt eine Tabelle mit kumulativen Zeitachsen aus der Datenbank.
Auswahl
- filter Filtert Zeilen aus einer Eingabetabelle anhand eines Prädikats.
- top Wählt die oberste Zeitachse nach einem Sortierwertausdruck aus.
- bottom Unterste Zeitachse nach einem Sortierwertausdruck auswählen.
- top_by Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.
- bottom_by Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.
Zeilenänderungen
- map Schreibt die Zeitachsenkennzeichnungs- und wertspalten jeder Zeile in einer Tabelle neu.
- valueSchreibt die Wertspalten jeder Zeile in einer Tabelle neu.
- time_shift Zeitachsen zeitlich vorwärts verschieben.
Zeitachsenausrichtung
- align Erzeugt eine ausgerichtete Tabelle mithilfe einer Ausrichtungsfunktion.
Aggregation
- group_by Fasst Zeilen nach zugeordneter Zeitachsenkennzeichnung und Zeitfenster zusammen.
- union_group_by Aggregiert Zeilen aus mehreren Tabellen.
- unaligned_group_by Aggregiert Zeilen nach der zugeordneten Zeitachsenkennzeichnung ohne Ausrichtung.
Union und Join
- join Natural Join mehrerer Tabellen.
- outer_join Äußeres Natural Join zweier Tabellen.
- union Union mehrerer Tabellen.
Zeithorizont und Zeitraum
- every Zeitraum für die Ausgabe der ausgerichteten Tabelle angeben.
- within Gibt den Zeitraum der Abfrageausgabe an.
- graph_period Gibt den bevorzugten Ausgabezeitraum zum Zeichnen von Zeitachsengrafiken an.
- window Gibt das Fenster für Ausrichtungsvorgänge an.
Benachrichtigungen
- condition Der Eingabetabelle eine boolesche Bedingungsspalte hinzufügen.
- absent_for Bedingung für das Fehlen einer Eingabe erstellen.
Sonstiges
- ident Identitätstabellenvorgang: keine Änderung an der Eingabetabelle.
- ratio Das Verhältnis der Wertspalten von zwei ausgerichteten Eingabetabellen berechnen.
- filter_ratio Berechnet das Verhältnis zweier gefilterter Summen der Eingabewertspalte.
- filter_ratio_by berechnet ein gruppiertes Verhältnis von zwei gefilterten Summenwerten der Spalte mit den Eingabewerten.

Abrufen

Die Ausgabe eines fetch-Tabellenvorgangs ist eine Tabelle, die namentlich aus der Cloud Monitoring-Zeitachsendatenbank abgerufen wird.

Die Ausgabe des Tabellenvorgangs resource ist die Menge aller Tabellen, die den Namen des überwachten Ressourcentyps im Namen haben. Auf jede resource-Tabelle muss anschließend ein metric-Tabellenvorgang folgen, der die einzelne Tabelle auswählt, deren Name diesen Messwert enthält. Vor dem metric-Tabellenvorgang kann es filter-Tabellenvorgänge geben, die die Zeilen in den resultierenden Tabellen einschränken.

`fetch` Erstellt eine Tabelle aus der Datenbank.

Signatur: fetch lit-TableName

Der Vorgang fetch ruft aus der Zeitachsen-Datenbank die Tabelle ab, deren Name dem Tabellennamen entspricht, der im Argument TableName angegeben wurde. Es ist ein Fehler, wenn der Tabellenname einen unbekannten Namen einer überwachten Ressource oder eines Messwerttyps enthält.

Diese Tabelle ist leer, wenn kein Messwert des angegebenen Typs aus der überwachten Ressource des angegebenen Typs erfasst wurde.

Wenn der Messwert Kumulativ ist, werden die Zeitachsen, aus denen die Tabelle besteht, effektiv in Delta-Zeitachsen konvertiert, wobei jeder Punkt die Wertänderung seit dem nächstjüngeren Punkt darstellt.

Der fetch-Vorgang kann auch den Satz aller Tabellen abrufen, die auf einer bestimmten überwachten Ressource basieren, indem einfach der Name der überwachten Ressource und kein Messwertname angegeben wird. Auf einen solchen fetch-Vorgang muss ein metric-Vorgang folgen, der die Tabelle mit den Daten für einen bestimmten Messwert auswählt. Der einzige Vorgang, der zwischen einem solchen fetch und dem nachfolgenden metric liegen kann, ist ein filter-Vorgang, der basierend auf den überwachten Ressourcenspalten filtert.

Diese Form von fetch ist nützlich, wenn wir mehr als einen Messwert für eine bestimmte überwachte Ressource abrufen möchten, wie in diesem Beispiel:

  fetch gce_instance | filter zone = 'asia-east1-a' |
  { metric compute.googleapis.com/instance/cpu/utilization ;
    metric compute.googleapis.com/instance/cpu/reserved_cores
  } | join | div
  gce_instance | (zone = 'asia-east1-a') |
  { compute.googleapis.com/instance/cpu/utilization ;
    compute.googleapis.com/instance/cpu/reserved_cores
  } | join | div

Dies entspricht

  { fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization ;
    fetch gce_instance :: compute.googleapis.com/instance/cpu/reserved_cores
  } | filter zone = 'asia-east1-a' | join | div

`metric` Erstellt die Tabelle für einen bestimmten Messwerttyp aus einer Reihe von Tabellen.

Signatur: Resource | metric lit-MetricName

Der Tabellenvorgang metric übernimmt eine Reihe von Tabellen, die von einem fetch -Tabellenvorgang erstellt wurden, der keinen Messwertnamen enthielt. Er wählt die Tabelle aus, die Daten für den Messwert enthält, der durch das Argument lit-MetricName angegeben wurde, und erzeugt diese Tabelle als Ausgabe. Es ist ein Fehler, wenn keine Messwertdefinition mit dem angegebenen Namen vorhanden ist. Wenn keine Eingabetabelle mit Daten für den angegebenen Messwertnamen vorhanden ist, wird eine leere Tabelle erstellt.

`fetch_cumulative` Erstellt eine Tabelle mit kumulativen Zeitachsen aus der Datenbank.

Signatur: fetch_cumulative lit-TableName

Der Tabellenvorgang fetch_cumulative ist mit dem Tabellenvorgang fetch identisch, mit der Ausnahme, dass kumulative Messwerte nicht automatisch in Delta-Messwerte konvertiert werden, wenn er abgerufen wird.

Auswahl

Die Auswahltabellen wählen Zeilen aus der Eingabetabelle zur Aufnahme in die Ausgabetabelle aus. Der Typ der Ausgabetabelle ist genau mit dem von der Eingabetabelle identisch.

`filter` Filtert Zeilen aus einer Eingabetabelle anhand eines Prädikats.

Signatur: ResourceOrTable | filter Bool

Der filter-Vorgang wertet den Argumentausdruck Bool für jede Zeile in einer einzelnen Eingabetabelle oder in der Sammlung von Tabellen aus, die durch einen resource-Vorgang benannt sind. Es werden nur die Zeilen der Eingabetabelle oder -tabellen, für die dieser Ausdruck als wahr ausgewertet wird, in die Ausgabetabelle oder -tabellen übernommen.

Wenn die Eingabe eine Sammlung von Tabellen ist, kann nur im Prädikat auf die Labels der überwachten Ressourcen verwiesen werden, die allen Tabellen gemeinsam sind.

`top` Wählt die oberste Zeitachse nach einem Sortierwertausdruck aus.

Signatur: Table | top lit-Int, [ Windowed(Num) ]

Der Tabellenvorgang top berechnet für jede Zeitachse in ihrer Eingabetabelle einen Sortierwert und wählt dann die Anzahl der Zeitachsen aus, die durch ihr Argument Int mit dem größten Sortierwert bereitgestellt werden. Das Argument Windowing berechnet den Sortierwert.

Das Argument Windowing(Num) wird auf Zeilen in einer Zeitachse angewendet, die innerhalb eines Wertzeitfensters liegen. Das Standardwertzeitfenster ist mit dem Abfragezeitfenster identisch. Wenn der Ausdruck ein Aggregationsausdruck ist (z. B. .min), handelt es sich um eine Aggregation über alle Zeilen, deren Endzeitstempel sich innerhalb des Wertfensters befindet. Wenn der Ausdruck ein Wertausdruck ist (z. B. .val(0)/.val(1)), wird er auf die jüngste Zeile im Wertfenster angewendet. Wenn es für eine Zeitreihe keine Zeilen innerhalb des Wertefensters gibt oder wenn das Argument Windowed(Num) keinen Wert für eine Zeitreihe ergibt, wird diese Zeitreihe nicht für die Ausgabe berücksichtigt.

Die Funktion within kann im Argument Windowed(Num) verwendet werden, um das Wertefenster durch Angabe einer Startzeit, einer Dauer und/oder einer Endzeit für das Fenster zu ändern.

Beispiele:

  | top 3

Wählen Sie drei Zeitachsen mit dem größten Wert für den jüngsten Punkt der Zeitachse aus.

  | top 7, .max

Wählen Sie sieben Zeitachsen mit dem größten Wert für das Maximum aller Punkte in der Zeitachse im Abfragefenster aus.

  | top 3, .min.within(-10h, 1h)

Dadurch werden drei Zeitachsen ausgewählt, bei denen der größte Wert des min-Reduzierers auf die Zeilen in jeder Zeitachse angewendet wird, die in einem Fenster liegen, das vor 10 Stunden beginnt und eine Stunde dauert.

`bottom` Unterste Zeitachse nach einem Sortierwertausdruck auswählen.

Signatur: Table | bottom lit-Int, [ Windowed(Num) ]

Der Tabellenvorgang bottom berechnet für jede Zeitachse in ihrer Eingabetabelle einen Sortierwert und wählt dann die Anzahl der Zeitachsen aus, die durch ihr Argument Int mit dem kleinsten Sortierwert bereitgestellt werden. Das Argument Windowing berechnet den Sortierwert.

Die Funktion within kann im Argument Windowed(Num) verwendet werden, um das Wertefenster durch Angabe einer Startzeit, einer Dauer und/oder einer Endzeit für das Fenster zu ändern.

Beispiele:

  | bottom 3

Wählen Sie drei Zeitachsen mit dem kleinsten Wert für den jüngsten Punkt der Zeitachse aus.

  | bottom 7, .min

Wählen Sie sieben Zeitachsen mit dem kleinsten Wert für alle Punkte in der Zeitachse im Abfragefenster aus.

  | bottom 3, .max.within(10h)

Dadurch werden drei Zeitachsen mit dem kleinsten Wert des max-Reduzierers ausgewählt, der auf die Zeilen in jeder Zeitachse angewendet wird, die in einem Fenster liegen, das vor 10 Stunden beginnt und bis jetzt andauert.

`top_by` Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.

Signatur: Table | top_by TSIDSel, lit-Int, [ Windowed(Num) ]

Der Tabellenvorgang top_by gruppiert Zeitachsen, die dieselbe Zeitachsenkennzeichnung haben, die vom Argument TSIDSel berechnet wurde. Innerhalb jeder Gruppe werden Zeitachsen auf dieselbe Weise ausgewählt wie top, wenn dieselben Argumente von Int und Windowing angegeben werden. Für jede Gruppe wird ein Sortierwert für jede Zeitachse in einer Gruppe berechnet und die Anzahl der durch das Argument Int angegebenen Zeitachsen mit dem größten Sortierwert ausgewählt. Das Argument Windowing berechnet den Sortierwert.

Die Funktion within kann im Argument Windowed(Num) verwendet werden, um das Wertefenster durch Angabe einer Startzeit, einer Dauer und/oder einer Endzeit für das Fenster zu ändern.

Beispiele:

  | top_by [zone], 1

Für jede Gruppe von Zeitachsen mit demselben Wert der Spalte "Zone" wird die Zeitachse mit dem größten Wert für den jüngsten Punkt in der Zeitachse ausgewählt.

  | top_by [project_id], 2, .max

Für jede Gruppe von Zeitreihen mit dem gleichen Wert der Spalte 'project_id' wählt diese die beiden Zeitreihen mit dem größten Wert für das Maximum aller Punkte in der Zeitreihe innerhalb des Abfragefensters aus.

  | top_by [zone], 1, .min.within(-10h, 1h)

Dadurch wird für jede Gruppe von Zeitachsen mit demselben Wert der Spalte "zone" die Zeitachse mit dem größten Wert des min-Reduzierers ausgewählt, der auf die Zeilen in jeder Zeitachse angewendet wird, die in einem Fenster beginnen, das vor 10 Stunden beginnt und hält eine Stunde lang.

`bottom_by` Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.

Signatur: Table | bottom_by TSIDSel, lit-Int, [ Windowed(Num) ]

Der Tabellenvorgang bottom_by gruppiert Zeitachsen, die dieselbe Zeitachsenkennzeichnung haben, die vom Argument TSIDSel berechnet wurde. Innerhalb jeder Gruppe werden Zeitachsen auf dieselbe Weise ausgewählt wie bottom, wenn dieselben Argumente von Int und Windowing angegeben werden. Für jede Gruppe wird ein Sortierwert für jede Zeitachse in einer Gruppe berechnet und die Anzahl der durch das Argument Int angegebenen Zeitachsen mit dem kleinsten Sortierwert ausgewählt. Das Argument Windowing berechnet den Sortierwert.

Die Funktion within kann im Argument Windowed(Num) verwendet werden, um das Wertefenster durch Angabe einer Startzeit, einer Dauer und/oder einer Endzeit für das Fenster zu ändern.

Beispiele:

  | bottom_by [zone], 1

Für jede Gruppe von Zeitachsen mit demselben Wert der Spalte "Zone" wird die Zeitachse mit dem kleinsten Wert für den jüngsten Punkt in der Zeitachse ausgewählt.

  | bottom_by [project_id], 2, .max

Für jede Gruppe von Zeitreihen mit dem gleichen Wert der Spalte 'project_id' wählt diese die beiden Zeitreihen mit dem kleinsten Wert für das Maximum aller Punkte in der Zeitreihe innerhalb des Abfragefensters aus.

  | bottom_by [zone], 1, .min.within(1h)

Dadurch wird für jede Gruppe von Zeitachsen mit demselben Wert der Spalte "zone" die Zeitachse mit dem kleinsten Wert des min-Reduzierers ausgewählt, der auf die Zeilen in jeder Zeitachse angewendet wird, die in einem Fenster beginnen, das vor 10 Stunden beginnt und hält eine Stunde lang.

Zeilenänderung

`map` Schreibt die Zeitachsenkennzeichnungs- und Wertspalten jeder Zeile in einer Tabelle neu.

Signatur: Tabelle | map [ RowToTSID ], [ RowToVal ]

Für jede Zeile in der Eingabetabelle werden zwei Transformationen angewendet:

Wenn die RowToTSID-Zuordnung angegeben ist, wird sie auf die Zeitachsenkennzeichnungsspalten dieser Zeile angewendet, um die Zeitachsenkennzeichnungsspalten der entsprechenden Ausgabezeile zu erzeugen. Wenn die RowToTSID-Zuordnung nicht angegeben ist (oder als _ angegeben ist), sind die Spalten für die Ausgabezeitachsenkennzeichnung mit der Eingabe identisch.
Wenn die Zuordnung RowToVal angegeben ist, wird sie auf die Wertspalten der Eingabezeile angewendet, um die Wertspalten der Ausgabezeile zu erzeugen. Ist die Zuordnung RowToVal nicht angegeben, sind die Wertspalten in der Ausgabe mit denen in der Eingabe identisch.

Es ist ein dynamischer Fehler, wenn Zeilen aus zwei verschiedenen Zeitachsen in der Eingabe derselben Zeitachse in der Ausgabe zugeordnet werden. In diesem Fall werden die aus einer der Eingabezeitachsen abgeleiteten Zeilen aus der Ausgabe gelöscht und eine Fehlermeldung wird ausgegeben.

Wenn die RowToTSID-Zuweisung Verweise auf Wertspalten oder Zeitspalten enthält, wird möglicherweise eine einzelne Eingabezeitachse in mehrere Ausgabezeitachsen aufgeteilt. Wenn die RowToTSID-Zuweisung Verweise auf Wertspalten oder Zeitspalten enthält, darf sie daher nur auf Tabellen angewendet werden, deren Wertspalten zur Zeitachsenart Gauge oder Delta gehören.

`value` Schreibt die Wertspalten jeder Zeile in einer Tabelle neu.

Signatur: Tabelle | value RowToVal

Die Zuordnung RowToVal wird auf die Spalten jeder Zeile in der Eingabetabelle angewendet, um die Wertspalten der entsprechenden Ausgabezeile zu erzeugen. Jede Ausgabezeile weist dieselben Zeitachsenkennzeichnungs- und Zeitspalten wie die Eingabezeile, aus der diese erzeugt wurde, und die von der Zuordnung RowToVal erzeugten Wertspalten auf.

`time_shift` Zeitachsen vorwärts verschieben.

Signature: Tabelle | time_shift lit-Duration

Für jede Zeile in der Eingabetabelle wird der Betrag, der durch das Argument Dauer festgelegt wurde, zu den Zeitspalten hinzugefügt. Dies hat zur Folge, dass jede Zeitachse in der Tabelle nacheinander verschoben wird.

Wenn die Eingabetabelle ausgerichtet ist, muss der Verschiebungsbetrag ein Vielfaches des Ausrichtungszeitraums sein, wodurch die Ausrichtung der Eingabetabelle beibehalten wird.

Zeitachsenausrichtung

`align` Erstellt eine ausgerichtete Tabelle mithilfe einer Ausrichtungsfunktion.

Signatur: Tabelle | align [ Aligner ]

Der Tabellenvorgang align verwendet die Ausrichtungsfunktion, die für das Argument Ausrichtung angegeben ist, um aus jeder Zeitachse in der Eingabe eine ausgerichtete Zeitachse zu erstellen und erstellt die Zeitachsen in der Ausgabetabelle.

Die Ausrichtungsbasiszeit ist die Endzeit des Abfragefensters und der Ausrichtungszeitraum wird durch einen der folgenden drei Schritte festgelegt:

Ein every-Tabellenvorgang, der den Zeitraum für diesen align-Tabellenvorgang festlegt.
Für die Ausrichtungsfunktion muss der Ausrichtungszeitraum der Fensterbreite entsprechen (siehe delta).
Eine externe Grafikschnittstelle erfordert einen bestimmten Ausrichtungszeitraum.

Die spezielle Methode zur Erstellung ausgerichteter Zeitachsen wird für die Ausrichtungsfunktion beschrieben, die dem Argument Ausrichtung übergeben wird.

Aggregation

Ein Aggregationstabellenvorgang unterteilt die Zeilen der Eingabetabelle in Gruppen. Für jede Gruppe von Eingabezeilen werden eine gemeinsame Zeitachsenkennzeichnung und gemeinsame Zeitspalten für die Gruppe berechnet, die Eingabezeilen aggregiert, um die Wertausgabespalten zu erstellen, und eine einzelne Zeile mit dem resultierenden Zeitachsenbezeichner sowie den Zeit- und Wertspalten ausgegeben.

Es gibt drei Arten der Aggregation

Räumliche Aggregation. Bei dieser Form der Aggregation werden für jede Eingabezeile neue Zeitachsen-ID-Spalten berechnet und alle Zeilen mit denselben neuen Zeitachsen-ID-Spalten und Endzeit gruppiert. Diese Art der Aggregation erfordert in der Regel eine ausgerichtete Eingabe, damit Zeilen aus verschiedenen Zeitachsen zeitlich in einer Gruppe zusammengefasst werden.
Zeitliche Aggregation. Bei dieser Form der Aggregation wird eine Reihe gültiger, ausgerichteter Ausgabezeiten und eine neue Endzeit für jede Zeile berechnet. Dabei wird die älteste ausgerichtete Endzeit angegeben, die nicht früher als die ursprüngliche Endzeit der Zeile ist. Zeilen mit derselben Zeitachsenkennung und derselben Endzeit werden zusammen gruppiert.
Fließende zeitliche Aggregation. Diese Form der Aggregation ähnelt der zeitlichen Aggregation, mit der Ausnahme, dass eine Zeile in mehr als einer Gruppe enthalten sein kann. Dies berechnet eine Reihe von Zeitfenstern, die jeweils eine spätere Kante mit einer gültigen ausgerichteten Endzeit und jeweils die gleiche feste Breite haben. Eine Zeile erhält eine Endzeit, die dem späteren Zeitpunkt jedes Fensters entspricht, in das sie fällt, und die Zeile wird mit allen anderen Zeilen gruppiert, die die gleiche Zeitachsenkennung und eine neue Endzeit haben. Wenn sich die Fenster überschneiden, kann eine Zeile mehr als eine neue Endzeit erhalten und somit in mehr als einer Gruppe enthalten sein.

Es ist möglich, räumliche Aggregationen mit einer der beiden Arten der temporären Aggregation in einem Tabellenvorgang zu kombinieren.

Ein wichtiger Unterschied zwischen temporärer und gleitender Aggregation besteht darin, dass einige Aggregatoren (z.B. Summe) Werte mit der Zeitachsenart Delta für nichtgleitende zeitliche Aggregation erzeugen, aber Gauge für gleitende zeitliche Aggregation. Der Grund dafür ist, dass sich die Zeitausdehnungen für zwei Punkte in einer Delta-Zeitachse nicht überlappen können, sodass die überlappenden Eingabefenster der gleitenden zeitlichen Aggregation nicht in den Zeitspalten der Delta-Zeitreihen-Ausgabereihen dargestellt werden können.

Wenn eine neue Zeitachsenkennzeichnung für eine Zeile berechnet wird, wird die neue Zeitachsenkennzeichnung durch ein map-Argument berechnet. Die Wertspalten für die Ausgabezeile werden durch ein map-Argument berechnet, wobei ein Aggregationsausdruck jede Wertspalte berechnet.

`group_by` Fasst Zeilen nach zugeordneter Zeitachsenkennzeichnung und Zeitfenster zusammen.

Signatur: Tabelle | group_by RowToTSID, [ RowSetToVal ]
Tabelle | group_by RowToTSID, lit-WindowDuration, [ RowSetToVal ]
Tabelle | group_by lit-WindowDuration, [ RowSetToVal ]

Der Tabellenvorgang group_by gruppiert Zeilen, indem die Zeitachsenkennzeichnungsspalten, Zeitspalten oder beides zugeordnet werden:

Wenn das Argument RowToTSID angegeben ist und das Argument WindowDuration nicht, wird die von diesem Zuordnungsargument erzeugte Zeitachsenkennzeichnung für jede Zeile in der Eingabetabelle berechnet und alle Zeilen werden gruppiert mit derselben Zeitachsenkennzeichnung und Endzeit.

In diesem Fall erfordert group_by eine ausgerichtete Tabelle als Eingabe, sodass verschiedene Zeitachsen Punkte mit derselben Endzeit haben. Wenn die Eingabetabelle nicht ausgerichtet ist, wird automatisch ein align-Tabellenvorgang zur Ausrichtung eingefügt.
Wenn das Argument WindowDuration angegeben wird und das Argument RowToTSID nicht, wird eine Gruppe von Zeilen für jede Zeitachsenkennzeichnung und jeden ausgerichteten Ausgabepunkt generiert. Die Zeilen in einer Gruppe sind alle Zeilen mit der angegebenen Zeitachsenkennzeichnung, deren Endzeit in ein Fenster zwischen der Ausgabezeit und dem Zeitpunkt liegt, der der frühere Zeitpunkt der Dauer ist.

Wenn das Argument Dauer einen sliding-Funktionsaufruf (z. B. sliding(1h)) enthält, kann das Fenster vom Ausrichtungszeitraum abweichen. Andernfalls muss das Argument Dauer mit dem Ausrichtungszeitraum übereinstimmen. Der Ausdruck window() stellt eine Dauer dar, die mit dem Ausrichtungszeitraum übereinstimmt. Wenn eine nicht gleitende Dauerexplizit angegeben wird, erzwingt er, dass der Zeitraum identisch ist, wenn kein Zeitraum explizit angegeben wurde.
Wenn sowohl das RowToTSID- als auch das WindowDuration-Argument angegeben werden, wird für jede Zeile eine neue zugeordnete Zeitachsenkennzeichnung berechnet, und es wird eine Gruppe für alle Zeilen mit derselben zugeordneten Zeitachsenkennzeichnung erstellt, deren Endzeit in einem Fenster zwischen der Ausgabezeit und der Zeit liegt, die früher ist.

Es wird eine Ausgabezeile für jede Gruppe erzeugt, die die gemeinsame Zeitachsenkennzeichnung der Zeilen in der Gruppe sowie einen Zeitstempel hat, der der Ausgabezeitpunkt der Gruppe (WindowDuration wurde angegeben) oder die gemeinsame Endzeit der Zeilen in der Gruppe ist (WindowDuration wurde nicht gegeben). Die Wertspalten in der Gruppe werden vom Argument RowSetToVal erzeugt. Jeder Aggregationsausdruck wird auf die Zeilen in der Gruppe angewendet und das Ergebnis ist die Wertspalte der Ausgabezeile.

Einige aggregierte Ausdrücke (z. B. sum) erzeugen Ausgabewertespalten mit der Art der Zeitachse Delta oder Gauge, je nach Art der Aggregation. Dies hängt davon ab, ob eine zeitliche Aggregation mit oder ohne Schieberegler durchgeführt wird. Zu diesem Zweck wird die Aggregation als temporäre Aggregation behandelt, wenn sie sowohl die zeitliche als auch die räumliche Aggregation kombiniert.

Ein group_by-Tabellenvorgang erzeugt immer ausgerichtete Ausgabetabellen. Wenn das Argument WindowDuration nicht angegeben wird, muss die Eingabetabelle ausgerichtet sein und die Ausgabetabelle hat dann dieselbe Ausrichtung. Wird das Argument WindowDuration angegeben, wird nur an einem Ausrichtungszeitpunkt ein Ausgabepunkt erzeugt und die Ausgabetabelle ausgerichtet.

Wenn das Zuordnungsargument RowToTSID Werte oder Zeitspalten in seinen Ausdrücken enthält, kann es sein, dass Zeitachsen in der Eingabetabelle in mehrere Zeitachsen in der Ausgabetabelle aufgeteilt werden.

`union_group_by` Aggregiert Zeilen aus mehreren Tabellen.

Signatur: Table++ | union_group_by RowToTSID, [ RowSetToVal ]
Table++ | union_group_by RowToTSID, lit-WindowDuration, [ RowSetToVal ]
Table++ | union_group_by lit-WindowDuration, [ RowSetToVal ]

Die Funktion union_group_by aggregiert Eingabezeilen genau wie die Funktion group_by, mit der Ausnahme, dass die Eingabezeilen aus mehreren Eingabetabellen angenommen werden.

Alle Eingabetabellen für union_group_by müssen dieselben Spalten (gleicher Name, derselbe Typ und bei Wertspalten) dieselbe Zeitachse haben. Wenn ausgerichtete Eingabetabellen für die Argumente von "Union_group_by" (kein Argument WindowDuration) erforderlich sind, müssen alle Eingabetabellen auf denselben Punkt ausgerichtet sein.

`unaligned_group_by` Aggregiert Zeilen nach zugeordneter Zeitachsenkennzeichnung ohne Ausrichtung.

Signatur: Tabelle | unaligned_group_by TSIDSel, [ RowSetToVal ]

Der unaligned_group_by-Tabellenvorgang hat dieselbe Funktion wie der Tabellenvorgang group_by, erfordert jedoch nicht, dass die Eingabetabelle ausgerichtet ist.

Dadurch wird die von TSIDsel erstellte Zeitachsenkennzeichnung für jede Zeile in der Eingabetabelle berechnet und alle Zeilen mit derselben resultierenden Zeitachsenkennung und Endzeit gruppiert. Alle Zeilen in der Gruppe haben dieselbe Endzeit und sollten dieselbe Startzeit haben. Wenn zwei Zeilen in einer Gruppe eine unterschiedliche Startzeit haben, ist ein dynamischer Fehler auszugeben und eine der Zeilen willkürlich auszuwählen, um sie aus der Gruppe zu entfernen.

Der Vorgang erzeugt eine Ausgabezeile für jede Gruppe der obigen Zeilengruppen. Die Ausgabezeile enthält die Zeitachsenkennzeichnung, die durch das TSIDsel-Zuordnungsargument erzeugt wird, sowie dieselbe Endzeit und (falls vorhanden) Startzeit wie die Eingabezeilen in der Gruppe. Die vom Zuordnungsargument RowSetToVal erzeugten Wertspalten werden auf alle Zeilen in der Gruppe angewendet.

Für den Tabellenvorgang unaligned_group_by muss die Eingabetabelle nicht ausgerichtet werden. Dies kann bedeuten, dass es unwahrscheinlich ist, dass mehrere Zeilen in einer Gruppe aggregiert sind. Der Vorgang setzt jedoch voraus, dass die in einer einzigen Ausgabezeitachse erfassten Zeilen (mit derselben Zeitachsenkennzeichnung) keine Endzeiten mit einer Dichte von mehr als einer Zeile pro Sekunde haben.

Union und Join

`join` Natural Join von mehreren Tabellen

Signatur: Table++ | join

Der Tabellenvorgang join verwendet zwei oder mehr Eingabetabellen und kombiniert die Zeilen in dieser Tabelle zu Zeilen in einer einzigen Ausgabetabelle. Dabei wird ein natürlicher "innerer Join" für die Zeitachsenkennzeichnung und die Endzeitspalten der Eingabetabellen durchgeführt.

Vorausgesetzt werden ausgerichtete Eingabetabellen, die alle am selben Zeitraum ausgerichtet und Tabellen der Zeitachsenart Delta oder Gauge sein müssen.

Die Ausgabetabelle enthält folgende Elemente:

Eine Spalte für die Zeitachsenkennzeichnung für jede eindeutige Spalte für die Zeitachsenkennzeichnung in einer der Eingabetabellen. Jede Spalte hat denselben Typ wie die entsprechende Spalte in den Eingabetabellen. Wenn zwei Tabellen Zeitachsenkennzeichnungs-Spalten mit demselben Namen aber unterschiedlichen Typen haben, gilt dies als Fehler.
Eine Endzeitspalte. Wenn eine der Eingabetabellen eine Tabelle der Zeitachsenart Delta ist, weist die Ausgabetabelle ebenfalls diese Delta-Zeitachsenart auf und enthält eine Startzeitspalte.
Eine Wertespalte für jede Wertspalte der Eingabetabellen. Die Reihenfolge ist die Reihenfolge der Eingabetabellen in grouped_table_op, die sie erstellt haben. Es gilt als Fehler, wenn zwei verschiedene Eingabetabellen Wertspalten mit demselben Namen haben.

Der Join berücksichtigt jedes Tupel, das aus einer Zeile aus jeder Eingabetabelle besteht. Für jedes dieser Tupel, das die folgenden Bedingungen erfüllt, wird eine Ausgabezeile erstellt:

Für jeden Zeitachsenkennzeichnungsspaltennamen, der in einer der Eingabetabellen erscheint, enthält die entsprechende Spalte denselben Wert für jede Tupelzeile, die diese Spalte aufweist.
Jede Zeile im Tupel hat dieselbe Endzeit.

Jede Ausgabezeile hat folgende Spaltenwerte:

Jede Zeitachsenspalte hat denselben Wert wie jede Zeile im Tupel, die diese Spalte aufweist.
Jede Zeitspalte hat denselben Wert wie die Zeilen im Eingabetupel.
Jede Wertspalte hat denselben Wert wie die Zeile im Tupel, aus der die Wertspalte stammt.

`outer_join` Äußeres Natural Join zweier Tabellen.

Signatur: Table++ | outer_join [ DefaultColumns ], [ DefaultColumns ]

Der Tabellenvorgang outer_join verwendet zwei Eingabetabellen und kombiniert die Zeilen in dieser Tabelle zu Zeilen in einer einzelnen Ausgabetabelle, indem ein natürlicher "äußerer Join" für die Zeitachsenkennzeichnung und die Endzeitspalten der Eingabetabellen ausgeführt wird.

Eines oder beide Argumente von DefaultColumns müssen angegeben werden. Entspricht jeder Eingabetabelle. Wenn diese für eine Tabelle angegeben ist, werden in dieser Tabelle Zeilen erstellt, wenn sie keine Zeile haben, die mit einer Zeile in der anderen Tabelle übereinstimmt. Die DefaultColumns geben die Wertspalten der erstellten Zeile an. Wenn für eine Tabelle eine DefaultColumnsangegeben wird, dann müssen die Zeitachsenkennzeichnungsspalten in dieser Tabelle eine Teilmenge der Zeitachsen der anderen Tabelle sein, und diese kann nur dann die Zeitachsenart Delta haben, wenn die andere Tabelle die Zeitachsenart Delta hat.

Vorausgesetzt werden ausgerichtete Eingabetabellen, die alle am selben Zeitraum ausgerichtet und Tabellen der Zeitachsenart Delta oder Gauge sein müssen.

Wie bei join enthält die Ausgabetabelle die folgenden Elemente:

Eine Spalte für die Zeitachsenkennzeichnung für jede eindeutige Spalte für die Zeitachsenkennzeichnung in einer der Eingabetabellen. Jede Spalte hat denselben Typ wie die entsprechende Spalte in den Eingabetabellen. Wenn zwei Tabellen Zeitachsenkennzeichnungs-Spalten mit demselben Namen aber unterschiedlichen Typen haben, gilt dies als Fehler.
Eine Endzeitspalte. Wenn eine der Eingabetabellen eine Tabelle der Zeitachsenart Delta ist, weist die Ausgabetabelle ebenfalls diese Delta-Zeitachsenart auf und enthält eine Startzeitspalte.
Eine Wertespalte für jede Wertspalte der Eingabetabellen. Die Reihenfolge ist die Reihenfolge der Eingabetabellen in grouped_table_op, die sie erstellt haben. Es gilt als Fehler, wenn zwei verschiedene Eingabetabellen Wertspalten mit demselben Namen haben.

Der Join berücksichtigt jedes Paar, das aus einer Zeile aus jeder Eingabetabelle besteht. Für jedes dieser Paare, das die folgenden Bedingungen erfüllt, wird eine Ausgabezeile erstellt:

Für jede Zeitachsenkennzeichnung, die in einer der Eingabetabellen erscheint, hat diese Spalte für jede Zeile in dem Paar, das diese Spalte enthält, denselben Wert.
Jede Zeile im Paar hat dieselbe Endzeit.

Jede Ausgabezeile hat folgende Spaltenwerte:

Jede Zeitachsenspalte enthält den Wert für diese Spalte wie jede Zeile in dem Paar, das diese Spalte enthält.
Jede Zeitspalte hat denselben Wert wie die Zeilen im Eingabepaar.
Jede Wertspalte hat denselben Wert wie die Zeile im Paar, aus dem diese Wertspalte stammt.

Wenn eine Zeile in einer Tabelle kein Paar mit einer Zeile in der anderen Tabelle bilden kann und in der anderen Tabelle DefaultColumns angegeben ist, wird ein Paar mit der Zeile von der ersten Tabelle und eine Standardzeile für die andere Tabelle erstellt. Die Standardzeile wird so erstellt:

Jede Spalte für die Zeitachsenkennzeichnung und die Zeitspalten haben denselben Wert wie die entsprechende Spalte in der ersten Tabellenzeile.
Die Wertspalten der Standardzeile werden von den DefaultColumns map erstellt. Dieser map muss einen Wert für jede Wertspalte in der Standardtabelle angeben.

`union` Union mehrerer Tabellen.

Signatur: Table++ | union

Der Tabellenvorgang union nimmt zwei oder mehr Eingabetabellen in eine einzelne Ausgabetabelle auf, die Zeilen aus allen Eingabetabellen enthält.

Die Eingabetabellen müssen dieselben Spalten (gleicher Name, derselbe Typ und bei Wertspalten) die gleiche Zeitachsenart haben. Die erzeugte Ausgabetabelle hat die gleichen Spalten wie die Eingabetabellen. Die Ausgabetabelle wird nur ausgerichtet, wenn alle Eingabetabellen mit einem gemeinsamen Zeitraum ausgerichtet sind.

Es ist ein dynamischer Fehler, wenn Streams aus zwei oder mehr verschiedenen Tabellen dieselbe Zeitachsenkennzeichnung haben. In diesem Fall wird einer der Streams mit einer doppelten Zeitachsenkennzeichnung willkürlich für die Ausgabe ausgewählt und der Rest wird gelöscht.

Zeithorizont und Zeitraum

Der Zeitraum, der beim Ausrichten der Zeitachsen in der Tabelle verwendet werden soll, wird durch den Befehl every festgelegt.

Die Abfrage erzeugt alle Ergebnisse als Punkte, deren Endzeit in einem Abfragefenster liegt. Die Dauer des Abfragefensters wird durch den Tabellenvorgang within festgelegt, der eine beliebige Startzeit, Endzeit oder Dauer angeben kann.

`every` Gibt den Zeitraum für die ausgerichtete Tabellenausgabe an

Signatur: Table | every lit-Duration

Der Tabellenvorgang every erfordert eine Eingabetabelle, die auf einen Eingabezeitraum ausgerichtet ist, der durch das Argument Dauer angegeben wird. Hierfür gibt es folgende Möglichkeiten:

Wenn die Eingabetabelle nicht ausgerichtet ist, wird ein align-Vorgang mit einer geeigneten Ausrichtungsfunktion für die Eingabetabelle eingefügt. Das Argument Dauer für die Ausrichtungsfunktion ist der Standardwert für den angegebenen Zeitraum.
Wenn die Tabelle ausgerichtet ist, aber keinen bestimmten erforderlichen Zeitraum hat, wird die Abfrage, die in den Tabellenvorgang every eingegeben wird, so angepasst, dass dieser Zeitraum erzeugt wird.
Es gilt als Fehler, wenn die Eingabetabelle an einem bestimmten Zeitraum ausgerichtet ist, dieser jedoch von dem im Argument Duration angegebenen Zeitraum abweicht.

`within` Gibt den Zeitraum der Abfrageausgabe an.

Signatur: Table | within lit-DateOrDuration, [ lit-DateOrDuration ]

Der Tabellenvorgang within gibt den Zeitraum der Abfrageausgabe an. Dies geschieht durch die Angabe von einem oder zwei von drei Werten: die älteste (Anfangs-)Zeit des Fensters, die jüngste (End-)Zeit des Fensters oder die Dauer des Fensters.

Wenn eines der beiden Argumente von within eine positive Dauer ist, wird die Breite des Fensters festgelegt. Es kann höchstens eines der Argumente eine positive Dauer sein.

Wenn das erste Argument ein Date ist, wird die Startzeit angegeben. Wenn das zweite Argument ein Date ist, wird die Endzeit angegeben. Wenn beide Date-Werte sind, muss der zweite Wert nach dem ersten liegen. Ein Date-Argument kann als Date-Literal oder mit einem negativen Dauer-Literal angegeben werden. Im späteren Fall ist die Zeit die angegebene Dauer vor der Ausgabe der Abfrage (jetzt).

Wenn nur ein Argument angegeben wird, verwendet das zweite Argument standardmäßig den Zeitpunkt, zu dem die Abfrage ausgegeben wurde (jetzt). In diesem Fall muss das erste Argument eine positive Dauer oder ein Date sein, das früher ist als der Zeitpunkt, zu dem die Abfrage ausgegeben wird.

`graph_period` Gibt den bevorzugten Ausgabezeitraum zum Zeichnen von Zeitachsengrafiken an.

Signatur: Table | graph_period lit-Duration

Der Tabellenvorgang graph_period transformiert seine Eingabetabelle, damit sie für die Darstellung als Grafik geeignet ist. Das Argument Duration gibt den Zeitraum zwischen Punkten an, die für die Grafik geeignet sind.

Dieser Vorgang wird automatisch in an den Metrics Explorer gesendete Abfragen eingefügt, wenn der Nutzer ihn nicht explizit der Abfrage hinzugefügt hat. In beiden Fällen legt Metrics Explorer den Wert des Arguments Dauer so fest, dass er für das tatsächliche Zeitfenster des Diagramms geeignet ist. Das explizite Hinzufügen von graph_period als Teil einer Abfrage ist nur sinnvoll, wenn die Abfrage der API übergeben wird.

Der Vorgang graph_period vergleicht das Argument Dauer mit dem Zeitraum der Eingabetabelle und führt einen der folgenden Schritte aus:

Wenn der Zeitraum der Eingabetabelle weniger als die Hälfte des Arguments Dauer beträgt, fungiert die graph_period-Operation als ein zeitlicher Reducer, dessen Fenster und Ausgabezeitraum durch das Argument Dauer angegeben werden. Jede Wertspalte in der Eingabetabelle wird ihrem Typ entsprechend aggregiert.
- Für eine Wertspalte des numerischen Typs werden drei Spalten in die Ausgabetabelle eingefügt. Diese werden erzeugt, indem die Eingabespalte mit den Aggregatoren min, mean und max aggregiert wird. Die Namen der Ausgabespalten sind der Name der Eingabespalte mit der Ergänzung .min, .mean bzw. .max.
- Für eine Wertspalte des Typs Bool werden drei Spalten in die Ausgabetabelle eingefügt. Diese werden erzeugt, indem die Eingabespalte mit den Aggregatoren min, mean und max generiert werden. Die Namen der Ausgabespalten sind der Name der Eingabespalte mit der Ergänzung .all_true, .mean bzw. .any_true.
- Für eine Spalte vom Typ Distribution wird eine einzelne Spalte mit demselben Namen durch die distribution-Aggregation erstellt, um die Gesamtheit aller Verteilungseingabewerte zu kombinieren, die in jedes Grafikzeitfenster fallen.
Wenn der Eingabetabellenzeitraum mehr als doppelt so lang ist wie das Argument Dauer, werden für jeden Punkt in der Eingabetabelle Kopien für den Zeitpunkt erstellt, der für den Ausgabezeitraum erforderlich ist.
Wenn der Eingabetabellenzeitraum weniger als doppelt so lang ist wie das Argument Dauer und mehr als halb so lang wie das Argument Dauer, wird die Eingabetabelle einfach in die Ausgabe kopiert.

Beachten Sie, dass das Verhalten einer Eingabetabelle nicht definiert ist, wenn sie mehr als eine Wertespalte oder eine String-Wertspalte hat. Der Metrics Explorer zeigt möglicherweise nur eine einzelne Spalte an oder gibt einen Fehler zurück, wenn keine Spalte angezeigt werden kann.

`window` Gibt das Fenster für Ausrichtungsvorgänge an.

Signatur: Table | window lit-Duration

Der window-Tabellenvorgang erfordert eine Eingabetabelle, die durch eine Ausrichtfunktion ausgerichtet wird, deren Fenster-Dauer-Argument das gleiche ist wie das auf dieser window-Tabellenvorgang angegebene Dauer-Argument. Dies wird auf eine der folgenden Arten verarbeitet:

Wenn die Eingabetabelle nicht ausgerichtet ist, wird ein align-Vorgang mit einer entsprechenden Ausrichtungsfunktion für die Eingabetabelle eingefügt. Das Argument Dauer für die Ausrichtungsfunktion wird durch das Argument Dauer dieses Tabellenvorgangs von window angegeben.
Wenn die Tabelle ausgerichtet ist, aber der Tabellenvorgang, der sie ausgerichtet hat, kein bestimmtes Ausrichtungsfenster hat, wird die Dauer aus diesem window-Argument als Ausrichtungsfensterargument verwendet.
Es ist ein Fehler, wenn die Eingabetabelle ausgerichtet ist und der ausgerichtete Tabellenvorgang eine Fenster-Dauer angibt, die sich vom Argument dieses window-Tabellenvorgangs unterscheidet.

Benachrichtigungen

Benachrichtigungsvorgänge dienen dazu, Benachrichtigungsrichtlinien zu definieren. Verwenden Sie diese Vorgänge nur zur Installation von Benachrichtigungen, nicht als Teil einer Abfrage.

Letztendlich bieten diese Vorgänge Möglichkeiten zum Erstellen von Abfragen, die zu einer Tabelle mit zwei Wertspalten führen: Eine boolesche, die angibt, ob die Benachrichtigung ausgelöst werden soll und ein Wert desselben Typs wie die Eingabe, der den aktuellsten Wert der Eingabe angibt.

`condition` Der Eingabetabelle eine boolesche Bedingungsspalte hinzufügen.

Signatur: Table | condition Bool

Der Tabellenvorgang condition fügt jeder Zeile der Eingabetabelle eine boolesche Wertspalte hinzu, um die Ausgabetabelle zu erstellen. Der Wert dieser Spalte ist der Wert des Arguments Bool, der auf die Zeile angewendet wird.

Kann zum Erstellen einer Benachrichtigungsabfrage verwendet werden. Die Ausgabetabelle enthält eine boolesche Spalte, die angibt, dass die Benachrichtigungsbedingung erfüllt ist. Über die Benachrichtigungseinrichtung wird festgelegt, ob und wann eine Benachrichtigung ausgelöst oder beendet werden soll.

Für den condition-Vorgang muss die Eingabetabelle ausgerichtet und von einer Abfrage mit einem expliziten Ausrichtungsfenster generiert werden. Dies wird durch ein Fensterargument für einen Ausrichtungsvorgang (z.B. | align rate(10m)) oder einen window-Tabellenvorgang bereitgestellt.

Beispiele:

  fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | window 5m
  | condition val() < .5

Dadurch wird eine Tabelle mit zwei Wertspalten erstellt. Die erste Spalte ist eine Bool-Spalte, die wahr ist, wenn die usage_time-Wertspalte der Eingabetabelle kleiner als .5 ist. Die zweite Spalte ist eine Kopie der Wertespalte usage_time aus der Eingabe.

`absent_for` Bedingung für das Fehlen einer Eingabe erstellen.

Signatur: Table | absent_for lit-Duration

Der Tabellenvorgang absent_for generiert eine Tabelle mit zwei Wertspalten, active und signal. Die Spalte active ist wahr, wenn Daten in der Tabelleneingabe fehlen, und andernfalls "false". Dies ist hilfreich, um eine Bedingungsabfrage zu erstellen, die bei einer fehlenden Benachrichtigung verwendet werden soll.

Für jede Eingabezeitachse erstellt absent_for eine ausgerichtete Ausgabezeitachse mit derselben Zeitachsenkennzeichnung wie die Eingabe. Der Ausrichtungszeitraum wird entweder durch einen folgenden every oder den Standardzeitraum angegeben.

Das Argument Dauer gibt ein Zeitlimit an. Die Spalte active für einen Ausgabepunkt ist falsch, wenn sich in der Eingabezeitachse ein Punkt innerhalb dieses Zeitlimits vor dem Zeitpunkt des Ausgabepunkts befindet. Wenn kein solcher Eingabepunkt vorhanden ist, gilt die Spalte active "true". Dies gibt an, dass die Eingabe innerhalb des Zeitlimits fehlt.

Wenn die Eingabetabelle Werte enthält, enthält die Spalte signal den Wert der ersten Wertspalte des letzten Eingabepunkts (innerhalb des Limits oder nicht). Wenn die Eingabetabelle keine Wertspalten enthält, ist die Spalte signal im Ausgabepunkt eine Ganzzahl, die die Anzahl der Minuten seit dem letzten Eingabepunkt angibt.

Für jeden Ausgabezeitpunkt sucht der Tabellenvorgang absent_for 24 Stunden vor diesem Zeitpunkt nach einem Eingabepunkt. Wenn innerhalb der letzten 24 Stunden kein Eingabepunkt vorhanden ist, wird für diese Zeit kein Punkt ausgegeben.

Beispiele:

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | absent_for 8h

Für jede usage_time aus einer virtuellen Maschine (gce_instance) erzeugt das absent_for eine ausgerichtete Zeitreihe, deren Ausgabepunkte eine active-Spalte haben, die wahr ist, wenn es einen Eingabepunkt innerhalb der letzten 24 Stunden, aber keine Punkte innerhalb der letzten 8 Stunden (8h) gibt. Dies ist eine geeignete Alerting-Abfrage.

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | value [] | absent_for 8h

Dies ist ähnlich wie im vorherigen Beispiel, aber der | value [] entfernt die Wertespalten von der Eingabe zur absent_for-Operation, sodass die signal auf die Zeit (in Minuten) seit dem letzten Eingabepunkt eingestellt wird.

Sonstiges

`ident` Identitätstabellenvorgang: Keine Änderung an der Eingabetabelle

Signatur: Table | ident

Der Vorgang der ident-Tabelle erzeugt keine Eingabetabelle.

Beispiel:

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time |
    { ident ; group_by [zone] } |
    join | value [zone_fraction: val(0) / val(1)]

Für jede Zeile in der angegeben Tabelle wird der Anteil ihres Werts im Verhältnis zur Gesamtsumme dieses Werts aus allen Instanzen in der Zone berechnet, in der sie sich befindet.

`ratio` Das Verhältnis der Wertspalten von zwei ausgerichteten Eingabetabellen berechnen.

Signatur: Table++ | ratio

Der Tabellenvorgang ratio verwendet zwei ausgerichtete Eingabetabellen, die Eingabe für die Zählertabelle bzw. die Eingabetabellentabelle. Beide Tabelleneingaben sollten genau eine Wertspalte eines numerischen Typs enthalten.

Die Spalten für die Zeitachsenkennzeichnung der Tabelle müssen eine Teilmenge der Spalten für die Zeitachsenkennzeichnung der Zählertabelle sein. Wenn beide Tabellen die gleichen Zeitachsen-ID-Spalten (Name und Typ) haben, wird für die Zählung des Standardwerts null verwendet.

`filter_ratio` Berechnet das Verhältnis zweier gefilterter Summen der Eingabewertspalte.

Signatur: Table | filter_ratio Bool, [ Bool ]

Der Tabellenvorgang filter_ratio verwendet eine Eingabetabelle mit genau einer Wertespalte eines numerischen Typs. Wenn die Eingabetabelle nicht ausgerichtet ist, wird ein align-Tabellenvorgang automatisch eingefügt, um die Ausrichtung durchzuführen.

Der filter_ratio-Vorgang aggregiert alle Eingabezeilen zu einem bestimmten Zeitstempel, berechnet eine Zähler- und Nennersumme und erstellt eine Zeitachse mit dem Verhältnis dieser Summen zu jedem Zeitstempel. Das erste Bool-Argument steuert das, was in die Zählersumme fließt, und das zweite Bool-Argument steuert das, was in die Nennersumme eingeht. Das zweite Argument ist optional und wird standardmäßig auf true gesetzt, wenn es nicht angegeben ist.

Die Bool-Argumente werden für jede Zeile ausgewertet. Wenn "true", wird die Wertspalte für diese Zeile in der Zähler- (erster Bool) oder Nennersumme (zweiter Bool) aufgenommen.

`filter_ratio_by` Berechnet ein gruppiertes Verhältnis von zwei gefilterten Summen der Eingabewertspalte.

Signatur: Table | filter_ratio_by RowToTSID, Bool, [ Bool ]

Der Tabellenvorgang filter_ratio_by nimmt eine Eingabetabelle an, die genau eine Wertspalte eines numerischen Typs enthält. Wenn die Eingabetabelle nicht ausgerichtet ist, wird ein align-Tabellenvorgang automatisch eingefügt, um die Ausrichtung durchzuführen.

Der filter_ratio_by-Vorgang gruppiert Zeilen, die dieselbe Zeitachsenkennzeichnung haben, die vom Argument RowToTSID berechnet wurde. Für jede Gruppe wird eine Zähler- und eine Nennersumme berechnet und eine Zeitachse mit dem Verhältnis dieser Summen zu jedem Zeitstempel erstellt. Das erste Bool-Argument steuert das, was in die Zählersumme fließt, und das zweite Bool-Argument steuert das, was in die Nennersumme eingeht. Das zweite Argument ist optional und wird standardmäßig auf true gesetzt, wenn es nicht angegeben ist.

Die Bool-Argumente werden für jede Zeile ausgewertet. Wenn "true", wird die Wertspalte für diese Zeile in der Zähler- (erster Bool) oder Nennersumme (zweiter Bool) aufgenommen.

Für jede Gruppe wird eine Zeitachse berechnet, wobei die Zeitachsen-ID berechnet wird, die vom Argument "RowToTSID" berechnet wurde.

Functions

In diesem Abschnitt werden alle Funktionen beschrieben, die in Ausdrücken (expr) in der Monitoring-Abfragesprache verwendet werden können.

Eingabezeilenspalten
- val Der Wert einer Wertspalte im Eingabepunkt (Zeile).
- end Die Endzeit des Eingabepunkts (Zeile).
- start Die Startzeit des Eingabepunkts (Zeile).
- older Ein Wert aus dem nächsten früheren Punkt (Zeile) in einer Zeitachse.
- adjacent_delta Die Wertänderung zwischen einem Eingabepunkt und dem nächst früheren Punkt.
- adjacent_rate Die Änderungsrate zwischen den Eingaben und den nächsten früheren Punkten (Zeilen).
- hash_tsid Gibt einen Hash der Spalten der Zeitachsenkennzeichnung zurück.
Logisch
- not Die logische Negation eines booleschen Werts.
- and Das logische "und" von zwei booleschen Werten.
- or Das logische "oder" von zwei booleschen Werten.
- true Der boolesche Wert "wahr".
- false Der boolesche Wert "false"
- has "True", wenn ein Mengenargument einen bestimmten Wert enthält.
- has_value "True", wenn ein Argumentausdruck einen Wert berechnet.
- if Ein Wert, der auf Basis einer Bedingung aus zwei Werten ausgewählt wird
- or_else Ein Wert oder, wenn es sich nicht um einen Wert handelt, ein anderer Wert.
Vergleich
- eq Gleich.
- ne Ungleich.
- ge Größer als oder gleich.
- gt Größer als.
- le Kleiner als oder gleich.
- lt Kleiner als.
Arithmetisch
- add Die Summe zweier Zahlen.
- sub Die Differenz zweier Zahlen.
- mul Das Produkt zweier Zahlen.
- div Das Verhältnis zweier Zahlen.
- int_div Der Quotient aus der Teilung zweier Ganzzahlen.
- abs Absoluter Wert.
- neg Der negative Wert einer Zahl.
- pos Identität für numerische Eingaben.
- rem Der Rest der Division von zwei Ganzzahlen.
Math
- sqrt Quadratwurzel.
- log Natürlicher Logarithmus.
- exp Potenziertes e.
- power Eine Zahl potenziert zu einer anderen Zahl.
- int_round Nächste ganze Zahl.
- int_floor Ganzzahl der Untergrenze.
- int_ceil Ganzzahl der Obergrenze.
String
- concatenate String-Verkettung.
- string_to_double String in Double umwandeln.
- string_to_int64 String in Int umwandeln.
- ascii_to_lower ASCII-Großbuchstaben in Kleinbuchstaben ändern.
- ascii_to_upper ASCII-Kleinbuchstaben in Großbuchstaben ändern.
- utf8_normalize Unicode-String, der sich für den Vergleich der Groß-/Kleinschreibung eignet.
Reguläre Ausdrücke
- re_full_match Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.
- re_partial_match Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.
- re_extract Werte extrahieren, die mit einem regulären Ausdruck in einem anderen String übereinstimmen.
- re_replace Ersetzen Sie die erste Übereinstimmung eines regulären Ausdrucks in einem anderen String.
- re_global_replace Ersetzt alle Übereinstimmungen eines regulären Ausdrucks in einem anderen String.
Aggregation
- sum Die Summe einer Gruppe numerischer Werte.
- distribution Eine Verteilung aus einer Gruppe von numerischen Werten oder Verteilungswerten.
- count Die Anzahl der Werte in einer Gruppe von Werten.
- row_count Die Anzahl der gefundenen Eingabezeilen.
- count_true Die Anzahl der wahren Werte in einer Gruppe boolescher Werte.
- min Minimum einer Gruppe numerischer Werte.
- max: Das Maximum einer Gruppe numerischer Werte
- diameter Das Maximum plus das Minimum einer Gruppe numerischer Werte.
- mean Der Mittelwert einer Gruppe numerischer Werte.
- stddev Die Standardabweichung einer Gruppe von Werten.
- variance Die Varianz einer Gruppe von numerischen Werten.
- covariance Die Kovarianz einer Gruppe von Wertenpaaren.
- median Der Mittelwert einer Gruppe numerischer Werte oder Verteilungswerte.
- percentile Ein Perzentil einer Gruppe von numerischen Werten oder Verteilungswerten.
- fraction_less_than Der Bruchteil einer Gruppe von Werten, die kleiner als ein fester Wert sind.
- fraction_true Der Anteil einer Gruppe boolescher Werte, die wahr sind.
- any_true Die Disjunktion einer Gruppe von booleschen Werten.
- all_true Die Verknüpfung einer Gruppe von booleschen Werten.
- pick_any Der Wert eines beliebigen Elements einer Gruppe von Werten (beliebig gewählt).
- singleton Der Wert des Elements einer Gruppe von Werten mit nur einem Element.
- unique Der gemeinsame Wert einer Gruppe von Werten (die alle gleich sein müssen).
- aggregate Der Standardaggregatwert aus einer Gruppe von Werten eines beliebigen Typs
- weighted_distribution Eine Verteilung aus einer Gruppe gewichteter Werte.
Ausrichten
- rate Die Änderungsrate zu ausgerichteten Zeitpunkten berechnen.
- delta Wertänderung zu ausgerichteten Zeitpunkten berechnen.
- any_true_aligner Richten Sie eine Bool-Zeitachse aus, indem Sie einen echten Wert in einem Fenster finden.
- count_true_aligner Richten Sie eine Bool-Zeitachse aus, indem Sie die wahren Werte in einem Fenster zählen.
- delta_gauge Wertänderung zu ausgerichteten Zeitpunkten als Gauge Zeitachse berechnen.
- fraction_true_aligner Richten Sie eine Bool-Zeitachse mit dem Anteil der tatsächlichen Werte in einem Fenster aus.
- int_mean_aligner Führen Sie die Ausrichtung durch, indem Sie den Mittelwert von Int-Werten in einem Fenster ermitteln.
- interpolate Interpolierte Werte zu ausgerichteten Zeitpunkten berechnen.
- mean_aligner Gleichen Sie den Mittelwert der Werte in einem Fenster ab.
- next_older Angleichung der Zeitpunkte durch Übergang von einer früheren zu einer späteren Zeit.
- next_younger Angleichung der Zeitpunkte durch Übergang von einer späteren zu einer früheren Zeit.
Einheiten bearbeiten
- scale Skaliert einen Wert auf eine andere Maßeinheit.
- cast_units Setzt die Maßeinheit eines Werts fest.
Regelmäßiges Fenster
- window Gibt ein Fenster an, das dem Ausrichtungszeitraum entspricht.
- sliding Gibt ein Fenster an, das gleitend (überlappend) und nicht disjunkt ist.
Verteilung
- count_from Die Anzahl der Werte in einem Verteilungswert.
- sum_from Die Summe der Werte in einem Verteilungswert.
- mean_from Der Mittelwert der Werte in einem Verteilungswert.
- stddev_from Die Standardabweichung der Werte in einem Verteilungswert.
- variance_from Die Varianz der Werte in einem Verteilungswert.
- median_from Der Mittelwert der Werte in einem Verteilungswert.
- percentile_from Ein Perzentil der Werte in einem Verteilungswert.
- fraction_less_than_from Der Bruchteil der Werte in einer Verteilung, die kleiner als ein fester Wert sind
- bounded_percentile_from Ein Perzentil der Werte innerhalb einer Grenze in einem Verteilungswert.
- rebucket Der in eine neue Bucket-Spezifikation konvertierte Verteilungswert.
Bucket-Spezifizierer
- powers_of Eine Bucket-Spezifikation mit exponentiell zunehmenden Bucket-Grenzen.
- fixed_width Eine Bucket-Spezifikation mit gleich großen Buckets.
- custom Eine Bucket-Spezifikation aus einer Liste von Bucket-Grenzen.
- num_buckets Legt die Anzahl der Buckets in einer Bucket-Spezifikation fest.
- bounds Untergrenze des ersten Buckets und Obergrenze des letzten Buckets festlegen.
- lower Legt die Untergrenze des ersten Buckets in einer Bucket-Spezifikation fest.
Sonstiges
- cast_double Int-Wert in Double umwandeln.
- cast_gauge Einen kumulativen oder Delta-Zeitachsenwert in Gauge umwandeln.
- within Gibt das Fenster der Sortierwertberechnung an.

Eingabezeilenspalten

Die Ausdrücke in einer Abfrage wirken sich auf die Spalten einer Eingabezeile aus. Auf eine Spalte wird normalerweise durch Angabe ihres Namens zugegriffen. Die Funktionen in diesem Abschnitt bieten alternative Möglichkeiten für den Zugriff auf Spalten.

Die Zeitspalten haben keine Spaltennamen und werden über die Funktionen start und end aufgerufen.

Die Wertspalten können über die Funktion val nach Name oder Position aufgerufen werden.

Die Funktion older gewährt Zugriff auf eine Spalte in der nächstfrüheren Zeile in einer Zeitachse.

`val` Der Wert einer Wertspalte im Eingabepunkt (Zeile).

Signatur: ImplicitRowInput val([ lit-Int ] ) → InputType (implizite Reiheneingabe)

Die Funktion val bietet eine Alternative zur Verwendung des Spaltennamens beim Zugriff auf die Wertspalten einer Eingabezeile. Das Argument Int (Standardwert 0) indexiert den geordneten Satz von Wertspalten (beginnend mit 0 für die erste Wertspalte) und gibt den Wert der Spalte mit dem indexierten Wert zurück. Dies ist der gleiche Wert, der sich aus der Verwendung des Spaltennamens ergibt.

Es ist ein statischer Fehler, wenn die Funktion val einen Index angibt, der negativ oder gleich oder größer oder gleich der Anzahl der Wertspalten ist.

`end` Die Endzeit des Eingabepunkts (Zeile).

Signatur: ImplicitRowInput end( ) → Date.Gauge (implizite Reiheneingabe)

Die Funktion end gibt den Datumswert in der Endzeitspalte der aktuellen Eingabezeile zurück.

`start` Die Startzeit des Eingabepunkts (Zeile).

Signatur: ImplicitRowInput start( ) → Date.Gauge (implizite Reiheneingabe)

Die Funktion start gibt den Datumswert in der Startzeitspalte der aktuellen Eingabezeile zurück. Wenn die Zeile keine Startzeit hat, da sie nur Gauge-Daten enthält, gibt die Startzeit no-value zurück.

`older` Ein Wert aus dem nächst früheren Punkt (Zeile) in einer Zeitachse.

Signatur: older(ColumnValue.CumulativeOK ) → FirstArgType.FirstArgKind
older(Date ) → Date.FirstArgKind

Das Argument für older muss ein Spaltenname oder eine Funktion sein, die einen Spaltenwert angibt (val, end, start). Der zurückgegebene Wert ist der Wert dieser Spalte in der Zeile, die die nächstfrühere Zeile der Eingabezeile derselben Zeitachse ist. Wenn eine solche vorherige Zeile nicht in derselben Zeitachse vorhanden ist, gibt older den Wert no-value zurück.

Die Spalte, auf die verwiesen wird, kann eine Wert-, Zeit- oder Zeitachsenkennzeichnungsspalte sein. Wenn es sich um eine Zeitachsenkennzeichnungs-Spalte handelt, wird older den gleiche Wert zurückgegeben wie der Argumentausdruck, auch wenn in derselben Zeitachse keine vorherige Zeile vorhanden ist.

`adjacent_delta` Die Wertänderung zwischen einem Eingabepunkt und dem nächst früheren Punkt.

Signatur: ImplicitRowInput adjacent_delta( ) → InputType (implizite Reiheneingabe)

Die Funktion adjacent_delta wird für Tabellen mit einer einzelnen numerischen Spalte (Int oder Double) oder Verteilungswertspalte verwendet.

Bei Anwendung auf eine Gauge-Zeitachse gibt adjacent_delta die Differenz zwischen dem Wert der Wertspalte in der aktuellen Eingabezeile und der Wertspalte in der nächstfrüheren Zeile derselben Zeitachse zurück, falls vorhanden. Wenn es keine nächstfrühere Zeile in derselben Zeitachse gibt, gibt adjacent_delta den Wert no-value zurück. Das Ergebnis hat den Zeitachsentyp Gauge.

Bei Anwendung auf eine Delta-Zeitachse gibt adjacent_delta den Wert der Wertspalte zurück, der die Zeitachse Delta bleibt. Jeder Ausgabepunkt hat denselben Wert, dieselbe Startzeit und das Ende wie der Eingabepunkt, von dem er generiert wurde.

Obwohl kumulative Zeitachsen nur selten in Abfragen verwendet werden, gibt adjacent_delta bei der Anwendung auf eine kumulative Zeitachse einen von zwei Werten zurück:

Wenn die Startzeit des Eingabepunkts vor der Endzeit des nächsten früheren Punkts liegt, gibt adjacent_delta den Wert des Eingabepunkts abzüglich des Werts des nächsten früheren Punkts zurück.
Wenn die Startzeit des Eingabepunkts später als die Endzeit des nächsten früheren Punkts ist, gibt adjacent_delta den Wert der Eingabepunkte zurück, d. h., der Wert 0 wird zur Startzeit subtrahiert.

Die resultierende Zeitachse hat eine Delta-Zeitachsenart und jeder Punkt ist eine Startzeit, die die ursprüngliche Startzeit oder die Endzeit des nächsten früheren Eingabepunkts ist, je nachdem, welcher Datentyp später ist.

`adjacent_rate` Die Änderungsrate zwischen der Eingabe und den nächsten früheren Punkten (Zeilen).

Signatur: ImplicitRowInput adjacent_rate( ) → Double.Gauge (implizite Reiheneingabe)

Die Funktion adjacent_rate wird für Tabellen mit einer einzelnen numerischen Spalte (Int oder Double) oder Verteilungswertspalte verwendet.

Bei Anwendung auf eine Gauge- oder Cumulative-Zeitachse gibt adjacent_rate die Änderungsrate zwischen dem Wert der Wertspalte in der aktuellen Eingabezeile zurück und der Wertspalte in der nächstfrüheren Zeile derselben Zeitachse, falls vorhanden. Dies ist die Differenz zwischen den Werten geteilt durch die Differenz zwischen der Endzeit der beiden Zeilen. Wenn es keine vorherige Zeile in derselben Zeitachse gibt, gibt adjacent_rate no-value zurück. Das Ergebnis hat den Zeitachsentyp Gauge.

Bei Anwendung auf eine Delta-Zeitachse gibt adjacent_rate die Wertspalte der aktuellen Eingabezeile geteilt durch die Differenz zwischen der Startzeit und der Endzeit dieser Zeile zurück.

`hash_tsid` Gibt einen Hash der Spalten der Zeitachsenkennzeichnung zurück.

Signatur: ImplicitRowInput hash_tsid([ lit-Int ] ) → Int (implizite Zeileneingabe)

Die Funktion hash_tsid gibt einen Hash der Werte in den Feldern der Zeitachsenkennzeichnung der aktuellen Eingabezeile zurück. Wenn ein Argument angegeben ist, wird es als See-Hash verwendet.

Logisch

`not` Die logische Negation eines booleschen Werts.

Signatur: not(Bool ) → Bool

Die not-Funktion verwendet einen booleschen Wert und gibt "true" zurück, wenn dieses Argument falsch ist, und "false", wenn dieses Argument wahr ist. Wenn das Eingabeargument no-value ist, ist dies das Ergebnis.

`and` Das logische "and" von zwei booleschen Werten.

Signatur: and(Bool, Bool ) → Bool

Die Funktion and gibt "true" zurück, wenn beide Eingaben wahr sind, und andernfalls "false". Wenn eine der Eingaben no-value ist, gibt and immer no-value zurück.

`or` Das logische "oder" von zwei booleschen Werten.

Signatur: or(Bool, Bool ) → Bool

Die Funktion or gibt "true" zurück, wenn eine der Eingaben wahr sind, und andernfalls "false". Wenn eine der Eingaben no-value ist, gibt or immer no-value zurück.

`true` Der boolesche Wert "true".

Signatur: ImplicitRowInput true( ) → lit-Bool (implizite Reiheneingabe)

Diese Funktion gibt den Literal-Bool-Wert true zurück.

`false` Der boolesche Wert "false".

Signatur: ImplicitRowInput false( ) → lit-Bool (implizite Reiheneingabe)

Diese Funktion gibt den Literalwert Bool false zurück.

`has` "True", wenn ein Set-Argument einen bestimmten Wert enthält.

Signatur: has(Set, lit-ColumnValue ) → Bool

Die Funktion has gibt "true" zurück, wenn der erste Argumentsatz das zweite Argument als Element enthält.

`has_value` "True", wenn ein Argumentausdruck einen Wert berechnet.

Signatur: has_value(ColumnValue ) → Bool

Die has_value-Funktion gibt "true" zurück, wenn ihr Argument einen Wert ergibt, und "false", wenn sie als no-value ausgewertet wird.

`if` Ein Wert, der aus zwei Werten ausgewählt wurde.

Signatur: if(Bool, ColumnValue.Delta, ColumnValue.Delta(gleich) ) → LastArgType.Delta
if(Bool, ColumnValue, ColumnValue(gleich) ) → LastArgType

Die Funktion if gibt ihr zweites oder drittes Argument zurück, je nach Wert (true oder false) des ersten Arguments.

if wertet das erste Bool-Argument aus. Wenn es no-value ist, ist das Ergebnis kein Wert. Wenn das erste Argument wahr ist, wird das zweite Argument zurückgegeben. Wenn das erste Argument falsch ist, wird das dritte Argument zurückgegeben.

Entweder kann das zweite oder dritte Argument kein Wert sein, aber das Ergebnis von if ist nur dann wertlos, wenn das Argument Bool kein Wert ist oder das zurückgegebene Argument kein Wert ist. Das nicht ausgewählte Argument kann "no-value" sein, ohne dass das Ergebnis "no-value" lautet.

Wenn die zweiten und dritten Argumente von if numerisch sind und eins der Argumente eine Einheit hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor if angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis der if hat die Einheit des zweiten Arguments, möglicherweise skaliert.

`or_else` Ein Wert oder, falls es sich um keinen Wert handelt, ein anderer Wert.

Signatur: or_else(ColumnValue, ColumnValue(same) ) → LastArgType

Die Funktion or_else gibt den Wert des ersten Arguments zurück, es sei denn, es ist no-value. In diesem Fall wird der Wert des zweiten Arguments zurückgegeben.

Die Funktion or_else gibt nur dann no-value zurück, wenn beide Argumente no-value sind.

Wenn die Argumente von or_else numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor or_else angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von or_else hat die Einheit des ersten Arguments, möglicherweise skaliert.

Vergleich

Die Vergleichsoperatoren vergleichen zwei Werte desselben Typs oder zwei numerische Werte (Int oder *Double) und geben einen Bool-Wert zurück. Im Gegensatz zu den meisten Funktionen geben Vergleichsoperatoren nie no-value zurück. Wenn eine Eingabe no value ist, wird davon ausgegangen, dass sie ein bestimmter Wert ist, der größer als jeder andere Wert ist.

`eq` Gleich.

Signatur: eq(Num, Num ) → Bool
eq(Comparable, Comparable(same) ) → Bool

Dadurch wird das erste Argument Comparable mit dem zweiten Argument Comparable verglichen und true zurückgegeben, wenn sie identisch sind, und false, wenn sie nicht identisch sind. Wenn ein Argument Int und das andere Double ist, wird das Argument Int vor dem Vergleich in einen Double-Wert konvertiert.

Wenn eine Eingabe no-value ist, wird der Vergleich durchgeführt und ein Bool-Argument zurückgegeben, true, wenn beide Werte no value sind, und ansonsten false. (Dadurch wird "no-value" als gleichwertig behandelt.)

Zum Vergleich von numerischen Argumenten, wenn eines der Argumente Einheiten enthalten, müssen beide Argumente Einheiten enthalten und die Einheiten müssen äquivalent sein. Das Ergebnis, da es Typ Bool ist, hat keine Einheiten. Wenn die Argumente für eq nicht identische Einheiten mit derselben Dimension haben, wird die Einheit automatisch für ein Argument automatisch skaliert vielleicht, sodass die Einheiten beider Argumente äquivalent sind.

Wenn die Argumente von eq numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor eq angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von "eq" ist vom Typ Bool und hat keine Einheiten.

Ein Vergleich zwischen der Spalte resource.project_id und einer literalen Zeichenfolge hat eine besondere Behandlung, um den Unterschied zwischen Projektnummern und Projektnamen zu behandeln, wie unter Abgleich der Spalte resource.project_id beschrieben.

`ne` Ungleich.

Signatur: ne(Num, Num ) → Bool
ne(Comparable, Comparable(same) ) → Bool

Dadurch wird das erste Argument Comparable mit dem zweiten Argument Comparable verglichen und false zurückgegeben, wenn sie identisch sind, und true, wenn sie nicht identisch sind. Wenn ein Argument Int und das andere Double ist, wird das Argument Int vor dem Vergleich in einen Double-Wert konvertiert.

Wenn eine Eingabe no-value ist, wird der Vergleich durchgeführt und ein Bool-Argument zurückgegeben, false, wenn beide Werte no value sind und sonst false. (Dadurch wird "no-value" als gleichwertig behandelt.)

Wenn die Argumente von ne numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor ne angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis "ne" ist vom Typ Bool und hat keine Einheiten.

`ge` Größer als oder gleich.

Signatur: ge(Num, Num ) → Bool
ge(Comparable, Comparable(same) ) → Bool

Dadurch wird das erste Argument Comparable mit dem zweiten Argument Comparable verglichen und true zurückgegeben, wenn das erste Argument größer oder gleich dem zweiten Argument ist, und ansonsten false. Wenn ein Argument Int und das andere Double ist, wird das Argument Int vor dem Vergleich in einen Double-Wert konvertiert.

Wenn eine Eingabe no-value ist, wird der Vergleich durchgeführt und ein Bool-Argument zurückgegeben; true, wenn der erste Wert no-value ist und andernfalls false. (Dadurch wird no-value als größer als jeder andere Wert behandelt.)

Wenn die Argumente von ge numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen die Einheiten sich entsprechen. Wenn sich die Einheiten nicht entsprechen, sie aber dieselbe Dimension haben, kann eines der Argumente automatisch so skaliert werden, dass es dieselben Einheiten erhält wie das andere Argument. Dies ist hier beschrieben. Es gilt als Fehler, wenn nur eines der Argumente Einheiten hat oder die Argumente Einheiten haben, die sich nicht entsprechen und keine Skalierung erfolgt.

Das Ergebnis von "ge" ist Typ Bool und hat keine Einheiten.

`gt` Größer als.

Signatur: gt(Num, Num ) → Bool
gt(Comparable, Comparable(same) ) → Bool

Dadurch wird das erste Argument Comparable mit dem zweiten Argument Comparable verglichen und true zurückgegeben, wenn das erste Argument größer als das zweite Argument ist, und anderenfalls false. Wenn ein Argument Int und das andere Double ist, wird das Argument Int vor dem Vergleich in einen Double-Wert konvertiert.

Wenn eine Eingabe no-value ist, wird der Vergleich durchgeführt und ein Bool-Argument zurückgegeben; false, wenn der zweite Wert no-value ist und andernfalls true. (Dadurch wird no-value als größer als jeder andere Wert behandelt.)

Wenn die Argumente von gt numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor gt angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von "gt" wird vom Typ Bool sein und keine Einheiten haben.

`le` Kleiner als oder gleich.

Signatur: le(Num, Num ) → Bool
le(Comparable, Comparable(same) ) → Bool

Dadurch wird das erste Argument Comparable mit dem zweiten Argument Comparable verglichen und true zurückgegeben, wenn das erste Argument kleiner oder gleich dem zweiten Argument ist. Andernfalls wird false zurückgegeben. Wenn ein Argument Int und das andere Double ist, wird das Argument Int vor dem Vergleich in einen Double-Wert konvertiert.

Wenn eine Eingabe no-value ist, wird der Vergleich durchgeführt und ein Bool-Argument zurückgegeben; true, wenn der zweite Wert no-value ist und andernfalls false. (Dadurch wird no-value als größer als jeder andere Wert behandelt.)

Wenn die Argumente von le numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor le angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von "le" ist Typ Bool und hat keine Einheiten.

`lt` Weniger als.

Signatur: lt(Num, Num ) → Bool
lt(Comparable, Comparable(same) ) → Bool

Dadurch wird das erste Argument Comparable mit dem zweiten Argument Comparable verglichen und true zurückgegeben, wenn das erste Argument kleiner als das zweite Argument ist, und anderenfalls false. Wenn ein Argument Int und das andere Double ist, wird das Argument Int vor dem Vergleich in einen Double-Wert konvertiert.

Wenn eine Eingabe no-value ist, wird der Vergleich durchgeführt und ein Bool-Argument zurückgegeben; false, wenn der erste Wert no-value ist und andernfalls true. (Dadurch wird no-value als größer als jeder andere Wert behandelt.)

Wenn die Argumente von lt numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor lt angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von "lt" ist vom Typ Bool und hat keine Einheiten.

Arithmetisch

Funktionen, die die arithmetischen Operatoren implementieren

`add` Die Summe zweier Zahlen.

Signatur: add(Num.Delta, Num.Delta ) → Num.Delta
add(Num, Num ) → Num
add(Duration, Duration ) → Duration
add(Date, Duration ) → Date
add(Duration, Date ) → Date

Die add-Funktion für zwei numerische Argumente gibt die Summe ihrer Argumente als Double-Wert zurück, wenn eine der Eingaben ein Double-Wert ist, andernfalls als Int-Wert. Wenn beide Eingaben die Zeitachsenart Delta sind, lautet die Ausgabe Zeitachsentypen. Andernfalls ist die Ausgabe eine Gauge-Zeitachsenart.

Die Funktion add für zwei Dauer-Argumente gibt die Dauer zurück, also deren Summe.

Die Funktion add für die Argumente Datum und Dauer gibt das Datum zurück, das die Dauer später als das Argument Datum ist. Wenn die Dauer negativ ist, ist das Ergebnis früher als das eingegebene Date (geht in die Vergangenheit zurück).

Wenn die Argumente von add numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor add angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von add hat die Einheit des ersten Arguments, möglicherweise skaliert.

`sub` Die Differenz zweier Zahlen.

Signatur: sub(Num.Delta, Num.Delta ) → Num.Delta
sub(Num, Num ) → Num
sub(Duration, Duration ) → Duration
sub(Date, Duration ) → Date
sub(Date, Date ) → Duration

Die Funktion sub für zwei Num-Argumente gibt das erste Argument abzüglich des zweiten Arguments als Double-Wert zurück, wenn eine der beiden Eingaben ein Double-Wert ist, andernfalls als Int. Wenn beide Eingaben vom Typ Delta sind, ist die Ausgabe vom Typ Delta. Andernfalls ist die Ausgabe eine Gauge-Zeitachsenart.

Die Argumente der sub-Funktion Dauer geben die Dauer als numerische Differenz zurück.

Die Funktion sub für die Argumente Datum und Dauer gibt das Datum zurück, das die Dauer früher als das Argument Datum ist. Wenn das Argument Dauer negativ ist, liegt das Ergebnis nach dem Argument Date.

Wenn die Argumente von sub numerisch sind und eines der Argumente Einheiten hat, müssen beide Argumente Einheiten haben. Wenn die Argumente Einheiten haben, müssen sie entweder äquivalent sein oder die hier aufgeführten Regeln müssen das Skalieren eines der Argumente erlauben, bevor sub angewendet wird, damit die Einheiten einander entsprechen. Es gilt als Fehler, wenn nur ein Argument Einheiten enthält oder beide Argumente Einheiten haben, die nicht vereinheitlicht werden können.

Das Ergebnis von sub hat die Einheit des ersten Arguments, möglicherweise skaliert.

`mul` Das Produkt zweier Zahlen.

Signatur: mul(Num.Delta, lit-Num ) → Num.Delta
mul(lit-Num, Num.Delta ) → Num.Delta
mul(Num, Num ) → Num
mul(Duration, Num ) → Duration
mul(Num, Duration ) → Duration

Die mul-Funktion für zwei numerische Argumente gibt das Produkt ihrer Argumente als Double-Wert zurück, wenn eine der Eingaben ein Double-Wert ist, andernfalls als Int-Wert. Wenn eine Eingabe die Zeitachse Delta ist und die andere Eingabe ein Literal ist, lautet die Ausgabe der Zeitachsentyp Delta. Andernfalls ist die Ausgabe eine Gauge-Zeitachsenart.

Die mul-Funktion für eine Num und Dauer ist die Dauer multipliziert mit Num als Dauer-Typ.

Wenn eines der numerischen Argumente Einheiten enthält, müssen beide Argumente Einheiten enthalten und die Einheiten müssen äquivalent sein. Die Einheit des Ergebnisses ist das Produkt der Einheiten der beiden Argumente, sofern diese Einheiten haben. Die einzige Ausnahme ist die Multiplikation mit einem Literal: Das Literal hat möglicherweise keine explizite Maßeinheit. Wenn das andere Argument eine Maßeinheit hat, wird die Einheit 1 dem Literal zugewiesen, wodurch das Ergebnis die Einheiten des anderen Arguments hat.

`div` Das Verhältnis zweier Zahlen.

Signatur: div(Num.Delta, lit-Num ) → Double.Delta
div(Num, Num ) → Double
div(Duration, Num ) → Duration
div(Duration, Duration ) → Double
div(Date, Duration ) → Double

Die Funktion div teilt das erste Num-Argument durch das zweite Num-Argument und gibt das Verhältnis als Double-Wert zurück.

Es wird kein Ergebnis erzeugt, wenn das zweite Argument Num 0 ist.

Die Funktion div teilt das erste Argument durch das zweite Argument auf und gibt das Verhältnis als Double-Wert zurück. Wenn ein Argument ein Date oder Dauer ist, wird der Wert als doppelter Wert dargestellt, der das Date oder die Dauer in Einheiten, ist die die vollständige interne Genauigkeit solcher Werte darstellen. Wenn das Ergebnis ein Datum oder eine Dauer ist, wird das Verhältnis als Wert mit denselben Einheiten interpretiert und gerundet auf den nächsten Wert, für den ein Date oder eine Dauer stehen.

Wenn ein Date-Wert durch einen Dauer-Wert geteilt wird, ist das Ergebnis der Double-Wert, der die Anzahl jener Dauer seit der Unix-Epoche (d'1970/01/01-00:00:00+00:00') ist. Daher ist d'2020/06/01-01:20:03' / 1s die Anzahl der Sekunden seit d'1970/01/01-00:00:00+00:00' bei d'2020/06/01-01:20:03'.

Die Funktion div erzeugt kein Ergebnis, wenn das zweite Argument 0 ist.

Wenn eines der numerischen Argumente Einheiten enthält, müssen beide Argumente Einheiten haben. Die Einheit des Ergebnisses, wenn die Argumente Einheiten haben, ist das Teilen der Einheit des ersten Arguments durch die Einheit des zweiten Arguments. Die einzige Ausnahme ist die Division durch ein Literal: Das Literal hat möglicherweise keine explizite Maßeinheit. Wenn das andere Argument also eine Maßeinheit hat, wird die Einheit 1 dem Literal zugewiesen. , wodurch das Ergebnis die Einheiten des anderen Arguments enthält.

`int_div` Der Quotient aus der Teilung zweier Ganzzahlen.

Signatur: int_div(Int, Int ) → Int
int_div(Duration, Int ) → Duration
int_div(Duration, Duration ) → Int
int_div(Date, Duration ) → Int

Die Funktion int_div teilt ihr erstes Argument durch ihr zweites Argument und gibt den Quotient als Int-Wert zurück. Wenn ein Argument ein Date oder Dauer ist, wird der Wert als Ganzzahlwert dargestellt, der das Date oder die Dauer in Einheiten, ist die die vollständige interne Genauigkeit solcher Werte darstellen. Wenn das Ergebnis ein Date oder eine Dauer ist, wird der numerische Wert als Wert mit denselben Einheiten interpretiert.

Wenn ein Date-Wert durch einen Dauer-Wert geteilt wird, ist das Ergebnis der Int-Wert, der die Anzahl jener Dauer seit der Unix-Epoche (d'1970/01/01-00:00:00+00:00') ist. Daher ist d'2020/06/01-01:20:03' / 1s die Anzahl der Sekunden seit d'1970/01/01-00:00:00+00:00' bei d'2020/06/01-01:20:03'.

Die Funktion int_div erzeugt kein Ergebnis, wenn das zweite Argument 0 ist.

`abs` Absoluter Wert.

Signatur: abs(Num ) → Num

Die abs-Funktion verwendet eine numerische Eingabe (Int oder *Double) und gibt einen Wert desselben Typs zurück, der dieselbe Größe wie die Eingabe hat und nicht negativ ist.

Das Ergebnis von abs nutzt dieselbe Maßeinheit.

`neg` Der negative Wert einer Zahl.

Signatur: neg(Num ) → Num
neg(Duration ) → Duration

Die neg-Funktion gibt das negative Argument zurück.

`pos` Identität für numerische Eingaben.

Signatur: pos(Num ) → Num
pos(Duration ) → Duration

Die Funktion pos gibt ein Argument zurück.

`rem` Der Rest der Teilung zweier Ganzzahlen.

Signatur: rem(Int, Int ) → Int
rem(Duration, Duration ) → Duration

Die Funktion rem teilt das erste Int-Argument durch das zweite Int-Argument und gibt den Rest als Int-Wert zurück.

Es wird kein Ergebnis erzeugt, wenn das zweite Argument Num 0 ist.

Die mit dem Ergebnis von Rem verbundene Maßeinheit ist die gleiche Einheit wie die Einheit des ersten Arguments, falls dies eine hat.

Mathematik

Einige mathematische Funktionen

`sqrt` Quadratwurzel.

Signatur: sqrt(Num ) → Double

Die sqrt-Funktion gibt die Quadratwurzel des Num-Arguments als Double-Wert zurück.

Die sqrt-Funktion erzeugt kein Ergebnis, wenn das Num-Argument kleiner als 0 ist.

Das Ergebnis von sqrt hat keine Maßeinheit.

`log` Natürlicher Logarithmus.

Signatur: log(Num ) → Double

Die Funktion log gibt den natürlichen Logarithmus des Num-Arguments als Double-Wert zurück.

log erzeugt kein Ergebnis, wenn das Num-Argument kleiner oder gleich 0 ist.

Das Ergebnis von log hat keine Maßeinheit.

`exp` Potenziertes e.

Signatur: exp(Num ) → Double

Der exp gibt e (die Basis der natürlichen Logarithmen) zurück, der mit dem Argument Num als Double-Wert potenziert wird.

Die exp-Funktionen geben bei Überlauf den Double-Wert "Infinity" zurück.

Das Ergebnis von exp hat keine Maßeinheit.

`power` Eine Zahl potenziert zu einer anderen Zahl.

Signatur: power(Num, Num ) → Double

Gibt den Wert des ersten Num-Arguments zurück, das mit dem zweiten Num-Argument als Double-Wert dargestellt wird. Wenn eines der Argumente ein Int ist, wird es vor dem Vorgang in ein Double konvertiert.

Das Ergebnis von power hat keine Maßeinheit.

`int_round` Nächste ganze Zahl.

Signatur: int_round(Double ) → Int

Die int_round-Funktion nimmt einen Double-Wert, rundet ihn auf die nächste Ganzzahl und gibt ihn als Int-Wert zurück. Wenn die Eingabe kein Wert ist oder das Ergebnis nicht als Int-Wert dargestellt werden kann, ist das Ergebnis no-value.

Das Ergebnis von int_round hat dieselbe Maßeinheit wie die Eingabe.

`int_floor` Ganzzahl der Untergrenze.

Signatur: int_floor(Double ) → Int

Die int_floor-Funktion nimmt einen Double-Wert, rundet ihn auf Minus bis zum nächsten ganzzahligen Wert und gibt ihn als Int-Wert zurück. Wenn die Eingabe kein Wert ist oder das Ergebnis nicht als Int-Wert dargestellt werden kann, ist das Ergebnis no-value.

Das Ergebnis von int_floor hat dieselbe Maßeinheit wie die Eingabe.

`int_ceil` Ganzzahl der Obergrenze.

Signatur: int_ceil(Double ) → Int

Die Funktion int_ceil nimmt einen Double-Wert, rundet ihn gegen die nächste Ganzzahl und gibt ihn als Int-Wert zurück. Wenn die Eingabe no-value ist oder das Ergebnis nicht als Int-Wert dargestellt werden kann, ist das Ergebnis no-value.

Das Ergebnis von int_ceil hat keine Maßeinheit.

String

Funktionen, die String-Werte verarbeiten.

`concatenate` String-Verkettung.

Signatur: concatenate(String, String ) → String

Die Funktion concatenate gibt die Verkettung der beiden Argumente von String zurück.

`string_to_double` String in Double umwandeln.

Signatur: string_to_double(String ) → Double

Die string_to_double-Funktion parst ihr String-Eingangsargument als Gleitkommazahl und gibt das Ergebnis als Double-Wert zurück. Wenn der String kein gültiger Gleitkommawert ist, ist das Ergebnis no-value.

Das Ergebnis von string_to_double hat keine Maßeinheit.

`string_to_int64` String in Int umwandeln.

Signatur: string_to_int64(String ) → Int

Die Funktion string_to_int64 parst das String-Eingabeargument als Ganzzahl und gibt das Ergebnis als Int-Wert zurück. Wenn der String kein gültiger ganzzahliger Wert ist oder nicht als Int-Wert dargestellt werden kann, lautet das Ergebnis no-value.

Das Ergebnis von string_to_int64 hat keine Maßeinheit.

`ascii_to_lower` ASCII-Großbuchstaben in Kleinbuchstaben ändern.

Signatur: ascii_to_lower(String ) → String

Die ascii_to_upper-Funktion verwendet ein String-Argument und gibt einen String-Wert zurück, der identisch ist, mit der Ausnahme, dass jeder ASCII-Großbuchstabe in die entsprechenden ASCII-Kleinbuchstaben konvertiert wurde. Alle anderen Zeichen bleiben unverändert.

`ascii_to_upper` Ändern der ASCII-Kleinbuchstaben in Großbuchstaben.

Signatur: ascii_to_upper(String ) → String

Die Funktion ascii_to_upper verwendet ein String-Argument und gibt einen String-Wert zurück, der identisch ist, mit der Ausnahme, dass jeder ASCII-Kleinbuchstaben in den entsprechenden Großbuchstaben umgewandelt wurde. Alle anderen Zeichen bleiben unverändert.

`utf8_normalize` Unicode-String, der sich für den Vergleich der Groß-/Kleinschreibung eignet.

Signatur: utf8_normalize(String ) → String

Die utf8_normalize-Funktion verwendet ein String-Argument und gibt einen String-Wert zurück, der sich für einen Vergleich der Eingabewerte eignet, wenn die Eingabe ein gültiger UTF8-codierter String ist.

Reguläre Ausdrücke

Funktionen, die Übereinstimmungen, Extraktionen und Änderungen mithilfe regulärer RE2-Ausdrücke durchführen.

`re_full_match` Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.

Signatur: re_full_match(String, lit-String ) → Bool

Die Funktion re_partial_match verwendet eine reguläre Zeichenfolge und einen regulären Ausdruck für einen String und gibt true zurück, wenn der gesamte Eingabestring mit dem regulären Ausdruck übereinstimmt. Andernfalls wird false zurückgegeben, auch wenn das Eingabestringargument no-value ist.

Ein Abgleich mit regulären Ausdrücken in der Spalte resource.project_id hat eine besondere Behandlung, um den Unterschied zwischen Projektnummern und Projektnamen zu behandeln, wie in Abgleich der Spalte resource.project_id beschrieben.

`re_partial_match` Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.

Signatur: re_partial_match(String, lit-String ) → Bool

Die Funktion re_partial_match verwendet eine reguläre Zeichenfolge und einen regulären Ausdruck für einen String und gibt true zurück, wenn ein Teil des Eingabestrings mit dem regulären Ausdruck übereinstimmt. Andernfalls wird false zurückgegeben, auch wenn das Stringargument no-value ist.

`re_extract` Werte extrahieren, die mit einem regulären Ausdruck in einem anderen String übereinstimmen.

Signatur: re_extract(String, [ lit-String ], [ lit-String ] ) → String

Die Funktion re_extract verwendet ein Eingabestringargument und zwei Literal-String-Argumente: einen regulären Ausdruck und einen Ersatzstring. Das Ergebnis wird durch Abgleich des Eingabestrings mit dem regulären Ausdruck und der ersetzenden Erfassungsgruppen im Ausdruck im Ersatzstring erstellt. Der Ersatzstring durch die ersetzten Erfassungsgruppen ist das Ergebnis.

Wenn das Argument für einen regulären Ausdruck nicht angegeben ist, wird standardmäßig "(.*)" verwendet, sodass der gesamte erste Argumentstring in einer Erfassungsgruppe enthalten ist.

Wenn das Argument für den Ersetzungsstring nicht angegeben ist, wird standardmäßig R"\1" verwendet, sodass die erste Ersetzungsgruppe der Ausgabestring ist.

Wenn der Eingabestring no-value ist, wenn der reguläre Ausdruck nicht übereinstimmte oder die Substitution von Erfassungsgruppen nicht funktioniert, wird kein Wert zurückgegeben.

`re_replace` Ersetzt die erste Übereinstimmung eines regulären Ausdrucks in einem anderen String.

Signatur: re_replace(String, lit-String, lit-String ) → String

Die Funktion re_replace verwendet ein String-Eingabeargument und zwei literale String-Argumente: einen regulären Ausdruck und einen Ersatzwert. Wenn der reguläre Ausdruck mit irgendeinem Teil des Eingabestrings übereinstimmt, wird der zurückgegebene Wert gebildet, indem die erste solche Übereinstimmung im Eingabestring durch den Ersatzstring ersetzt wird.

Wenn der Eingabestring no-value ist oder wenn es keine Übereinstimmung gibt, wird der Eingabestring der zurückgegebene Wert.

`re_global_replace` Ersetzt alle Übereinstimmungen eines regulären Ausdrucks in einem anderen String.

Signatur: re_global_replace(String, lit-String, lit-String ) → String

Die Funktion re_global_replace verwendet ein Eingabestringargument und zwei literale String-Argumente: einen regulären Ausdruck und einen Ersatzwert. Das Ergebnis wird aus dem Eingabestring erstellt, indem jede disjunkte Übereinstimmung des regulären Ausdrucks (von links nach rechts) durch den Ersatzstring ersetzt wird.

Wenn der Eingabestring no-value ist oder keine Übereinstimmung vorliegt, ist der Eingabestring der zurückgegebene Wert.

Aggregation

Eine Aggregationsfunktion kombiniert eine Reihe von Eingabewerten zu einem endgültigen Ausgabewert. Sie werden verwendet, wenn mehrere Eingabezeilen gruppiert und in einer einzigen Ausgabezeile zusammengefasst werden.

Eine Aggregationsfunktion verwaltet einen internen Aggregationsstatus. Der Argumentausdruck für die Aggregationsfunktion wird für jede der gruppierten Eingabezeilen einmal ausgewertet und der resultierende Wert (falls vorhanden) wird an die Aggregationsfunktion übergeben, um in seinem internen Status angesammelt zu werden. Sobald dies für alle Zeilen in der Gruppe erfolgt ist, erzeugt die Aggregationsfunktion ihren Ausgabewert, der zum Erstellen von Wertspalten in der einzelnen Ausgabezeile verwendet werden soll.

Zum Beispiel wertet mean(memory_usage), angewendet auf eine Reihe von Zeilen mit einer memory_usage-Spalte, den Argumentausdruck memory_usage für jede Zeile aus und integriert den resultierenden Wert (falls einer erzeugt wird) in den internen Zustand der Aggregationsfunktion mean (die eine Summe von Werten und eine Anzahl von Werten sein kann). Wenn alle Zeilen verarbeitet wurden, erzeugt der Reducer mean einen Wert aus seinem internen Status (die Summe dividiert durch die Anzahl).

Die meisten Aggregatfunktionen, die mit numerischen Werten oder Verteilungswerten arbeiten, übertragen die Maßeinheit ihrer Eingabe auf die Ausgabe. Es gibt folgende Ausnahmen:

count und row_count – die Ausgabe hat die Einheit 1.
variance – die Ausgabe ist das Quadrat der Eingabe.
covariance – die Ausgabe ist das Produkt der Einheiten der beiden Eingaben.
fraction_less_than und fraction_true geben die Einheit 10^2.% ihrer Ausgabe.

`sum` Die Summe einer Gruppe numerischer Werte.

Signatur: sum(Num ) → Num.Delta (temporal only)
sum(Distribution ) → Double.Delta (temporal only)
sum(Num ) → Num.Gauge (sliding temporal only)
sum(Distribution ) → Double.Gauge (sliding temporal only)
sum(Num ) → Num.FirstArgKind
sum(Distribution ) → Double.FirstArgKind

Wenn der Argumentausdruck numerisch ist (Int oder *Double), wird die Summe der Werte zurückgegeben, die an ihn übergeben werden.

Wenn der Argumentausdruck ein Verteilungswert ist, gibt diese Funktion die Summe der Populationswerte in allen Verteilungswert zurück, die an sie übergeben werden.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double-Wert ergibt, wirkt sich diese Eingabezeile nicht auf die Summe aus.

Bei numerischen Eingaben (Int oder Double) ist das Ergebnis der gleiche Typ (Int* oder Double) wie der Eingabeausdruck. Für Verteilungs-Eingabewerte ist der Ergebnistyp Double.

Die Ausgabe hat den Zeitachsentyp Delta, wenn nichtgleitende zeitliche Aggregationen oder nur eine räumliche Aggregation durchgeführt wird und der Typ der Eingabezeitachse ebenfalls Delta ist.

Die mit dem Ergebnis von sum verbundene Maßeinheit entspricht der Einheit der Eingabe.

`distribution` Eine Verteilung aus einer Gruppe numerischer Werte oder Verteilungswerte.

Signatur: distribution(Num, lit-BucketSpecification ) → Distribution.Delta (temporal only)
distribution(Num, lit-BucketSpecification ) → Distribution.Gauge
distribution(Distribution ) → Distribution.Delta (temporal only)
distribution(Distribution ) → Distribution.Gauge (sliding temporal only)
distribution(Distribution ) → Distribution.FirstArgKind

Wenn das erste Argument ein Num-Wert ist, werden die Eingabewerte in einem Verteilungsergebnis gesammelt, dessen Bucket-Spezifikation durch das Argument Lit-Bucketer angegeben wird.

Wenn das erste Argument ein Verteilungs-Wert ist, werden die Verteilungen zu einem Verteilungsergebnis zusammengeführt, das die Population aller Eingabeverteilungen enthält. Die resultierende Verteilungs-Bucket-Spezifikation wird anhand der Eingabeverteilung-Bucket-Spezifikationen bestimmt. Wenn die Bucket-Spezifikationen identisch sind, wird diese Bucket-Spezifikation verwendet. Wenn es eine andere Bucket-Spezifikation gibt, wird eine neue zusammengeführte Bucket-Spezifikation verwendet. Diese zusammengeführte Spezifikation ist in der Regel nicht genauer als die Eingabe-Bucket-Spezifikation mit der geringsten Genauigkeit.

Wenn jedoch der erste Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double ergibt, wirkt sich diese Eingabezeile nicht auf das Perzentil aus.

Die mit dem Ergebnis von distribution verbundene Maßeinheit entspricht der Einheit der Eingabe.

`count` Die Anzahl der Werte in einer Gruppe von Werten.

Signatur: count(ColumnValue ) → Int.Delta (nur zeitlich)
count(ColumnValue ) → Int.Gauge

Gibt die Anzahl der Werte zurück, die an die Funktion übergeben wurden. Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt oder einen nicht endlichen Double-Wert ergibt, wird er nicht gezählt.

Die Ausgabe hat den Zeitachsentyp Delta, wenn eine nichtgleitende zeitliche Aggregation durchgeführt wird.

Die mit dem Ergebnis von count verbundene Maßeinheit ist 1.

`row_count` Die Anzahl der gefundenen Eingabezeilen.

Signatur: ImplicitRowSetInput row_count( ) → Int.Delta (temporal only)
ImplicitRowSetInput row_count( ) → Int.Gauge

Die row_count-Aggregationsfunktion gibt die Anzahl der Zeilen zurück, für die diese Aggregation erfolgt. Im Gegensatz zu count verwendet row_count kein Argument und es ist egal, ob ein Wert aus der Zeile berechnet werden könnte.

Die Ausgabe hat den Zeitachsentyp Delta, wenn eine nichtgleitende zeitliche Aggregation durchgeführt wird.

Die mit dem Ergebnis von count verbundene Maßeinheit ist 1.

`count_true` Die Anzahl der wahren Werte in einer Gruppe boolescher Werte.

Signatur: count_true(Bool ) → Int.Delta (nur zeitlich)
count_true(Bool ) → Int

Die booleschen Eingabewerte werden erfasst und das Ergebnis ist die Anzahl der wahren Eingabewerte.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die Ausgabe hat den Zeitachsentyp Delta, wenn eine nichtgleitende zeitliche Aggregation durchgeführt wird.

Die mit dem Ergebnis von count_true verbundene Maßeinheit ist 1.

`min` Das Minimum einer Gruppe numerischer Werte.

Signatur: min(Num ) → Num

Dies erfasst die numerischen Werte, die an sie übergeben werden, und gibt den Mindestwert zurück. Wenn der Ergebnistyp dem Eingabetyp entspricht.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von min verbundene Maßeinheit entspricht der Einheit der Eingabe.

`max` Das Maximum einer Gruppe numerischer Werte.

Signatur: max(Num ) → Num

Diese erfasst die numerischen Werte, die an sie übergeben werden, und gibt den Höchstwert zurück. Wenn der Ergebnistyp dem Eingabetyp entspricht.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von max verbundene Maßeinheit entspricht der Einheit der Eingabe.

`diameter` Das Maximum plus das Minimum einer Gruppe numerischer Werte.

Signatur: diameter(Num ) → Num

Dadurch werden die numerischen Werte erfasst, die an sie übergeben werden, und die Differenz zwischen dem Maximum und dem Minimum der Werte zurückgegeben. Wenn der Ergebnistyp mit dem Eingabetyp übereinstimmt (Int oder Double).

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von diameter verbundene Maßeinheit entspricht der Einheit der Eingabe.

`mean` Der Mittelwert einer Gruppe numerischer Werte.

Signatur: mean(Summable ) → Double

Wenn der Argumentausdruck numerisch ist (Int oder *Double), wird der Mittelwert der Werte zurückgegeben, die an ihn übergeben werden.

Wenn der Argumentausdruck vom Typ Verteilung ist, wird der Mittelwert aller Werte in allen Verteilungen zurückgegeben.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double-Wert ergibt, wirkt sich diese Eingabezeile nicht auf den Mittelwert aus.

Die mit dem Ergebnis von mean verbundene Maßeinheit entspricht der Einheit der Eingabe.

`stddev` Die Standardabweichung einer Gruppe von Werten.

Signatur: stddev(Summable ) → Double

Wenn der Argumentausdruck numerisch ist (Int oder *Double), gibt dies die Standardabweichung der an sie übergebenen Werte zurück.

Wenn der Argumentausdruck ein Verteilungs-Wert ist, wird die Standardabweichung aller Werte in allen Verteilungen zurückgegeben.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double-Wert ergibt, wirkt sich diese Eingabezeile nicht auf die Standardabweichung aus.

Die mit dem Ergebnis von stddev verbundene Maßeinheit entspricht der Einheit der Eingabe.

`variance` Die Varianz einer Gruppe numerischer Werte.

Signatur: variance(Summable ) → Double

Wenn der Argumentausdruck numerisch ist (Int oder *Double), wird die Varianz der Werte zurückgegeben, die an ihn übergeben werden.

Wenn der Argumentausdruck den Typ Verteilung hat, wird die Varianz aller Werte in allen Verteilungen zurückgegeben.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double-Wert ergibt, wirkt sich diese Eingabezeile nicht auf die Varianz aus.

Mit dem Ergebnis der Funktion variance ist keine Maßeinheit verbunden.

`covariance` Die Kovarianz einer Gruppe von Wertpaaren

Signatur: covariance(Num, Num ) → Double

Dies gibt die Kovarianz der Paare numerischer Werte (Int oder *Double) zurück, die an sie übergeben werden.

Wenn für eine Eingabezeile einer der Argumentausdrücke keinen Wert oder einen nicht endlichen Double-Wert ergibt, wirkt sich diese Eingabezeile nicht auf die Kovarianz aus.

Mit dem Ergebnis der Funktion covariance ist keine Maßeinheit verbunden.

`median` Der Medianwert einer Gruppe numerischer Werte oder Verteilungswerte.

Signatur: median(Summable ) → Double

Wenn der Argumentausdruck numerisch ist (Int oder *Double), gibt dies eine Schätzung der Medianwerte der Werte zurück, die an ihn übergeben werden. Der Medianwert wird berechnet, indem ein Verteilungswert aus den Werten der Population mit Bucket-Grenzen erstellt wird, die 10% voneinander entfernt sind, wodurch der Fehler in der Schätzung um diesen Betrag begrenzt wird.

Die Bucket-Spezifikation, mit der ein Distribution-Wert aus numerischer Eingabe abgeleitet wird, um ein Medianwert zu schätzen, lautet powers_of(1.05).num_buckets(500).lower(.01). Sie beinhaltet einen Wertebereich von .01 bis ca. 4e+8. Obwohl sie viele Anwendungsfälle abdeckt, ist es möglicherweise erforderlich, die Funktion scale zum Anpassen der Eingabe zu verwenden, z. B. von By in MiBy oder „MBy“, wenn der Bereich der Anzahl der Byte im Gigabyte- oder Terabyte-Bereich liegt.

Wenn der Argumentausdruck ein Verteilungs-Wert ist, wird eine Schätzung des Medianwerts der zusammengeführten Population von Werten aus allen Verteilungen zurückgegeben. Der Median wird berechnet, indem alle Eingabeverteilungen zu einer Verteilung zusammengeführt und der Median geschätzt wird. Die Genauigkeit des Medianwerts hängt von den Bucket-Grenzen der Eingabeverteilung ab.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double-Wert ergibt, wirkt sich diese Eingabezeile nicht auf die Standardabweichung aus.

Die mit dem Ergebnis von median verbundene Maßeinheit entspricht der Einheit der Eingabe.

`percentile` Ein Perzentil einer Gruppe von numerischen Werten oder Verteilungswerten.

Signatur: percentile(Summable, lit-Num ) → Double

Das Argument lit-Num gibt ein Perzentil im Bereich von 0 bis 100 an.

Wenn der erste Argumentausdruck numerisch ist (Int oder Double), wird eine Schätzung des Perzentils der Population der Werte zurückgegeben, die an ihn übergeben werden. Der Perzentil wird berechnet, indem ein Verteilungswert aus den Werten der Population mit Bucket-Grenzen erstellt wird, die 10% voneinander entfernt sind, wodurch der Fehler in der Schätzung um diesen Betrag begrenzt wird.

Die Bucket-Spezifikation, mit der ein Distribution-Wert aus numerischer Eingabe abgeleitet wird, um ein Perzentil zu schätzen, lautet powers_of(1.05).num_buckets(500).lower(.01). Sie beinhaltet einen Wertebereich von .01 bis ca. 4e+8. Obwohl sie viele Anwendungsfälle abdeckt, ist es möglicherweise erforderlich, die Funktion scale zum Anpassen der Eingabe zu verwenden, z. B. von By in MiBy oder „MBy“, wenn der Bereich der Anzahl der Byte im Gigabyte- oder Terabyte-Bereich liegt.

Wenn der Argumentausdruck ein Distribution-Wert ist, wird eine Schätzung des Medianwerts der zusammengeführten Population von Werten aus allen Verteilungen zurückgegeben. Der Perzentil wird berechnet, indem alle Eingabeverteilungen zu einer Verteilung zusammengeführt und der Perzentil geschätzt wird. Die Genauigkeit des Perzentils hängt von den Bucket-Grenzen der Eingabeverteilungen ab.

Wenn jedoch der erste Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double ergibt, wirkt sich diese Eingabezeile nicht auf das Perzentil aus.

Die mit dem Ergebnis von percentile verbundene Maßeinheit entspricht der Einheit der Eingabe.

`fraction_less_than` Der Anteil einer Gruppe von Werten, die kleiner als ein fester Wert sind.

Signatur: fraction_less_than(Summable, lit-Num ) → Double

Wenn das erste Argument ein numerischer Wert (Int oder *Double) ist, gibt dies den Bruchteil der an das erste Argument übergebenen Wertesammlung zurück, der kleiner als das lit-Num-Argument ist. Beim Berechnen dieses Bruchteils werden unendliche Werte vom Typ Double und "Not-a-Value"-Werte vom Typ Int und Double ignoriert.

Wenn das erste Argument ein Verteilungs-Wert ist, kombiniert dies die Populationen aller übergebenen Verteilungen und schätzt den Anteil der Werte in der Gesamtheit dieser aggregierten Verteilung, die unter dem Wert des Arguments lit-Num liegen.

Die mit dem Ergebnis von fraction_less_than verbundene Maßeinheit ist 10^2.%.

`fraction_true` Der Bruchteil einer Gruppe boolescher Werte, die wahr sind.

Signatur: fraction_true(Bool ) → Double

Die booleschen Eingabewerte werden erfasst und das Ergebnis ist ein Double-Wert im Bereich von 0 bis 1, der dem Anteil der Eingabewerte entspricht, die wahr sind.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von fraction_true verbundene Maßeinheit ist 10^2.%.

`any_true` Die Disjunktion einer Gruppe boolescher Werte.

Signatur: any_true(Bool ) → Bool

Die Funktion any_true berechnet den Wert true, wenn alle Eingabewerte true sind, und gibt ansonsten false zurück.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

`all_true` Die Verknüpfung einer Gruppe von booleschen Werten.

Signatur: all_true(Bool ) → Bool

Die Funktion all_true berechnet den Wert true, wenn alle zugehörigen Eingabewerte true sind, und gibt ansonsten false zurück.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

`pick_any` Der Wert eines beliebigen Elements einer Gruppe von Werten (beliebig gewählt).

Signatur: pick_any(ColumnValue ) → FirstArgType

Diese Funktion gibt einen der an sie übergebenen Werte zurück, der willkürlich ausgewählt wird.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von pick_any verbundene Maßeinheit entspricht der Einheit der Eingabe, falls vorhanden.

`singleton` Der Wert des Elements einer Gruppe von Werten mit nur einem Element.

Signatur: singleton(ColumnValue ) → FirstArgType

Diese Funktion gibt den Wert des Argumentausdrucks so zurück, wie er für eine einzelne Zeile ausgewertet wurde. Wenn der Argumentausdruck einen Evaluierung ergibt und einen Wert für mehr als eine Zeile erzeugt, ist dies ein Fehler, auch wenn er als zuvor erzeugter Wert ausgewertet wird.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von singleton verbundene Maßeinheit entspricht der Einheit der Eingabe.

`unique` Der gemeinsame Wert einer Gruppe von Werten (die alle gleich sein müssen).

Signatur: unique(Comparable ) → FirstArgType

Die Funktion unique gibt den Wert zurück, der mit jedem Wert übereinstimmt, der ihr übergeben wurde. Wenn es einen solchen Wert nicht gibt (der Funktion wurden mindestens zwei verschiedene Werte übergeben), wird ein Fehler generiert und einer der an sie übergebenen Werte zurückgegeben.

Wenn der Argumentausdruck für eine Eingabezeile keinen Wert ergibt, wirkt sich diese Eingabezeile nicht auf das Ergebnis aus.

Die mit dem Ergebnis von unique verbundene Maßeinheit entspricht der Einheit der Eingabe.

`aggregate` Der Standardaggregatwert aus einer Gruppe von Werten eines beliebigen Typs

Signatur: aggregate(Num ) → Num.Delta (nur zeitlich)
aggregate(Distribution ) → Distribution.Delta (nur zeitlich)
aggregate(Num ) → Num.Gauge (nur gleitend zeitlich)
aggregate(Distribution ) → Distribution.Gauge (nur gleitend zeitlich)
aggregate(Num ) → Num.FirstArgKind
aggregate(Distribution ) → Distribution.FirstArgKind
aggregate(Bool ) → Bool
aggregate(String ) → String

Die Funktion aggregate führt eine Aggregation durch, die vom Typ der Eingabe abhängt.

Für Int- und Double-Eingaben ist dies mit dem Aggregator sum identisch.
Für die Verteilungs-Eingabe ist dies mit dem Aggregator distribution identisch.
Für die Bool-Eingabe ist dies mit dem Aggregator any_true identisch.
Für die String-Eingabe ist dies derselbe wie der Aggregator pick_any.

`weighted_distribution` Eine Verteilung aus einer Gruppe von gewichteten Werten.

Signatur: weighted_distribution(Num, Int, lit-BucketSpecification ) → Distribution.Delta (nur zeitlich)
weighted_distribution(Num, Int, lit-BucketSpecification ) → Distribution.Gauge

Die Eingabewerte werden in einem Verteilungsergebnis erfasst, dessen Bucket-Spezifikation durch das Argument lit-Bucketer angegeben wird. Das erste Argument ist der Wert, der der Verteilung hinzugefügt werden soll, und das zweite Argument ist die Gewichtung dieses Werts. Ein Wert N mit einer Gewichtung von M wird durch M-Instanzen des Werts N in der Verteilung dargestellt.

Wenn jedoch der zweite Argumentausdruck für eine Eingabezeile keinen Wert oder einen nicht endlichen Double ergibt, wirkt sich diese Eingabezeile nicht auf das Perzentil aus.

Die mit dem Ergebnis von weighted_distribution verbundene Maßeinheit entspricht der Einheit der Eingabe.

Ausrichten

Ausrichtungsfunktionen werden vom Tabellenvorgang align verwendet, um eine ausgerichtete Tabelle zu erstellen, deren Zeitachse Punkte mit Zeitstempeln in regelmäßigen Intervallen hat.

Zusätzlich zum expliziten Argument Dauer verwendet eine Ausrichtungsfunktion eine Eingabezeitachse und einen Zeitpunkt und erzeugt einen Ausgabepunkt für diesen bestimmten Zeitpunkt.

Die Ausrichtungsfunktion interpolate erzeugt einen Wert zu einem bestimmten Zeitpunkt, indem sie einen Wert von zwei angrenzenden Eingabepunkten interpoliert, deren Zeitstempel den Ausgabe-Zeitstempel überspannen.

Die Ausrichtungsfunktionen next_older und next_younger erzeugen den Wert aus dem einzelnen Punkt in der Eingabezeitachse, dessen Zeitstempel nur unmittelbar vor oder unmittelbar nach dem Ausgabezeitstempel liegt.

Die Ausrichtungsfunktionen delta, rate und delta_gauge berechnen ihre Ausgabe anhand der Änderung des Werts der Eingabezeitachse für das Zeitfenster zwischen der Endzeit des Ausgabepunkts und dem Argument Dauer früher. Diese Wertänderung wird so berechnet:

Daher kann der Wert der Eingabezeitachse zu einem beliebigen Zeitpunkt durch lineare Interpolation zwischen dem nächsten Punkt vor und dem nächsten Punkt nach der Ausgabezeit berechnet werden. Die Änderung des Werts über ein bestimmtes Fenster ist die Differenz zwischen dem interpolierten Wert am früheren Zeitpunkt des Fensters und dem späteren Zeitpunkt.
Die Änderung im Fenster ist die Summe des Werts aller Punkte, deren Darstellung vollständig im Fenster liegt, und der Anteil der Anteile des Werts Punkte, deren Umfang das Fenster teilweise überschneidet.
Bei einer kumulativen Zeitachse wird die Interpolation eines Werts zwischen zwei aufeinanderfolgenden Punkten mit derselben Startzeit durch die lineare Interpolation zwischen den beiden Werten vorgenommen. Die Interpolation zwischen zwei aufeinanderfolgenden Punkten mit unterschiedlichen Startzeiten (so liegt die Startzeit des späteren Punkts zwischen den Endzeiten der beiden Punkte) wird so gemacht:
- Wenn die Ausgabezeit zwischen der Endzeit des vorherigen Punkts und der Startzeit des späteren Punkts liegt, ist das Ergebnis der Wert des vorherigen Punkts. (Keine Änderung zwischen dem vorherigen Punkt und der Zurücksetzenszeit.)
- Wenn die Ausgabezeit zwischen dem Beginn und dem Ende des späteren Punkts liegt, ist der Wert die lineare Interpolation zwischen null (beim Beginn) und dem Wert des Punkts.
Bei einer kumulativen Zeitachse ist die Wertänderung in einem bestimmten Fenster die Differenz zwischen dem interpolierten Wert am früheren Zeitpunkt des Fensters und dem späteren Zeitpunkt sowie einer Korrektur für das Zurücksetzen. Für jede Zurücksetzenszeit, die innerhalb des Zeitfensters liegt, wird der Wert des Punkts unmittelbar vor dieser Zurücksetzenszeit dem Änderungswert hinzugefügt, um zu berücksichtigen, dass der Zeitachsenwert zu diesem Zeitpunkt zurückgesetzt wird auf 0.

Die Aggregatorausrichter-Funktionen, mean_aligner, int_mean_aligner, wenden eine Aggregationsfunktion auf die Eingabepunkte an, die in ein Zeitfenster fallen, dessen Breite durch das Argument Dauer gegeben ist und dessen späterer Zeitpunkt der Zeitstempel des Ausgabepunkts ist. Das Ergebnis dieser Aggregation ist der Wert des Ausgabepunkts.

Die Maßeinheit der Ausgabe einer Ausrichtungsfunktion ist normalerweise identisch mit der der Eingabe. Es gibt folgende Ausnahmen:
- Die Ausgabe von rate hat die Einheit der Eingabe geteilt durch die Einheit "s".
- Die Ausgabe von count_true_aligner hat die Einheit 1.
- Die Ausgabe von fraction_true_aligner hat die Einheit 10^2.%

`rate` Änderungsrate zu ausgerichteten Zeitpunkten berechnen.

Signatur: ImplicitRowInput rate([ lit-Duration ] ) → Double.Gauge (implizite Reiheneingabe)

Der rate-Ausrichter arbeitet mit Eingabezeitachsen mit einer einzelnen Wertspalte vom Typ Int oder *Double. Es wird immer eine Ausgabetabelle mit einer einzelnen Wertspalte vom Typ Double und dem Zeitachsentyp Gauge erstellt.

Der rate-Ausrichter berechnet die Änderung des Werts der Zeitachse über das Fenster (wie hier beschrieben) und teilt diese durch die Breite des Fensters in Sekunden ab. Das Fenster reicht von der Zeit des Ausgabepunkts bis zur früheren Zeit des Dauer-Parameters.

Der Standardwert für das Argument Dauer ist der Ausrichtungszeitraum. Anders als bei der Ausrichtungsfunktion 'delta' ist es nicht erforderlich, dass der Ausrichtungszeitraum und die Fensterbreite übereinstimmen.

`delta` Wertänderung zu ausgerichteten Zeitpunkten berechnen.

Signatur: ImplicitRowInput delta([ lit-Duration ] ) → InputType.Delta (implizite Reiheneingabe)

Der delta-Ausrichter arbeitet mit Eingabezeitachsen mit einer einzelnen Wertspalte vom Typ Summable (Int, Double oder Verteilung) und die Ausgabe ist eine Zeitachse, deren Wertspalte vom gleichen Typ ist, aber den Zeitachsentyp Delta hat.

Der Aligner "Delta_Gauge" berechnet die Änderung des Werts der Eingabezeitachse für das Zeitfenster zwischen der Ausgabezeit und dem vorigen Argument Dauer. Der Beginn des Ausgabepunkts ist das Argument Dauer vor der Ausgabezeit liegend (Endzeit des Punkts).

Für den delta-Ausrichter ist es erforderlich, dass das Argument Dauer dem Ausrichtungszeitraum entspricht, auf den er ausgerichtet wird. Der Standardwert für das Argument Dauer ist der Ausrichtungszeitraum.

`any_true_aligner` Richten Sie eine Bool-Zeitachse aus, indem Sie einen wahren Wert in einem Fenster finden.

Signatur: ImplicitRowInput any_true_aligner([ lit-Duration ] ) → Bool.Gauge (implizite Reiheneingabe)

Die Funktion any_true_aligner wird für eine Eingabetabelle mit einer einzelnen Wertspalte vom Typ Bool ausgeführt und erzeugt eine Ausgabetabelle mit einer einzelnen Wertspalte vom Typ Bool und einem Zeitachsentyp Gauge.

Das Argument Dauer gibt die Breite eines Zeitfensters für jeden Ausgabepunkt an, der zum Zeitpunkt dieses Ausgabepunkts endet. Wenn das Argument Dauer nicht angegeben ist, wird standardmäßig der Ausrichtungszeitraum verwendet. Der Wert eines Ausgabepunktes ist true, wenn ein beliebiger Eingabepunkt im Fenster auf wahr verweist, andernfalls ist er false.

`count_true_aligner` Richten Sie eine Bool-Zeitachse aus, indem Sie die wahren Werte in einem Fenster zählen.

Signatur: ImplicitRowInput count_true_aligner([ lit-Duration ] ) → Int.Gauge (implizite Reiheneingabe)

Die Funktion count_true_aligner wird für eine Eingabetabelle mit einer einzelnen Wertspalte vom Typ Bool ausgeführt und erzeugt eine Ausgabetabelle mit einer einzelnen Wertspalte vom Typ Int und einem Zeitachsentyp Gauge.

Das Argument Dauer gibt die Breite eines Zeitfensters für jeden Ausgabepunkt an, der zum Zeitpunkt dieses Ausgabepunkts endet. Wenn das Argument Dauer nicht angegeben ist, wird standardmäßig der Ausrichtungszeitraum verwendet. Der Wert eines Ausgabepunkts ist die Anzahl der Eingabepunkte im Fenster mit dem Wert true.

`delta_gauge` Änderung des Werts zu ausgerichteten Zeitpunkten als Gauge-Zeitachse berechnen.

Signatur: ImplicitRowInput delta_gauge([ lit-Duration ] ) → InputType.Gauge (implizite Reiheneingabe)

Der delta_gauge-Ausrichter arbeitet mit Eingabezeitachsen mit einer einzelnen Wertspalte vom Typ Summable (Int, Double oder Distribution) und die Ausgabe ist eine Zeitachse, deren Wertspalte vom gleichen Typ ist, aber den Zeitachsentyp Gauges hat.

Der delta_gauge-Ausrichter berechnet die Änderung des Werts der Eingabezeitserie über das Fenster (wie hier beschrieben). Das Fenster reicht von der Zeit des Ausgabepunkts bis zur früheren Zeit des Dauer-Parameters.

`fraction_true_aligner` Richten Sie eine Bool-Zeitachse an dem Anteil der wahren Werte in einem Fenster aus.

Signatur: ImplicitRowInput fraction_true_aligner([ lit-Duration ] ) → Double.Gauge (implizite Reiheneingabe)

Die Funktion fraction_true_aligner wird für eine Eingabetabelle mit einer einzelnen Wertspalte vom Typ Bool ausgeführt und erzeugt eine Ausgabetabelle mit einer einzelnen Wertspalte vom Typ Double und Art der Zeitachse

Das Argument Dauer gibt die Breite eines Zeitfensters für jeden Ausgabepunkt an, der zum Zeitpunkt dieses Ausgabepunkts endet. Wenn das Argument Dauer nicht angegeben ist, wird standardmäßig der Ausrichtungszeitraum verwendet. Der Wert eines Ausgabepunkts ist der Anteil aller Eingabepunkte im Fenster, die den Wert true haben.

`int_mean_aligner` Abgleichen durch Ermittlung des Mittelwerts von Int-Werten in einem Fenster.

Signatur: ImplicitRowInput int_mean_aligner([ lit-Duration ] ) → Int.Gauge (implizite Reiheneingabe)

Die Funktion int_mean_aligner wird für eine Eingabetabelle mit einer einzelnen Wertspalte vom Typ Int und dem Zeitachsentyp Gauge oder Delta ausgeführt. Es wird eine Ausgabetabelle mit einer einzelnen Wertspalte vom Typ Int und dem Zeitachsentyp Gauge erstellt.

Das Argument Dauer gibt die Breite eines Zeitfensters für jeden Ausgabepunkt an, der zum Zeitpunkt dieses Ausgabepunkts endet. Wenn das Argument Dauer nicht angegeben ist, wird standardmäßig der Ausrichtungszeitraum verwendet. Der Wert eines Ausgabepunktes ist der Mittelwert der Wertpunkte der Eingabetabelle, die auf dieses obige Fenster verweisen, gerundet auf den nächsten ganzzahligen Wert.

`interpolate` Interpolierte Werte zu ausgerichteten Zeitpunkten berechnen.

Signatur: ImplicitRowInput interpolate([ lit-Duration ] ) → InputType.Gauge (implizite Reiheneingabe)

Der interpolate-Ausrichter bearbeitet eine Eingabetabelle mit einer einzelnen Wertspalte vom Typ (Int oder *Double) und dem Zeitachsentyp Gauge. Es wird eine Ausgabetabelle mit einer einzelnen Wertspalte desselben Typs und desselben Zeitachsentyps erstellt.

Wenn die Ausgabezeit für die interpolate-Ausrichter-Funktion mit der Endzeit eines Punkts in der Eingabezeitachse übereinstimmt, wird diese für den Ausgabepunkt verwendet. Andernfalls interpolate Aligner berücksichtigt die Eingabepunkte, deren Endzeit der nächstgelegene frühere Punkt und spätere Punkt für die Ausgabezeit ist. Wenn sie innerhalb des Dauer-Arguments des jeweils anderen liegen, ist der Ausgabewert die lineare Interpolation zwischen denjenigen zu Punkten zum Ausgabezeitpunkt. Wenn kein Eingabepunkt früher als die Ausgabezeit oder kein Eingabepunkt später als die Ausgabezeit ist oder wenn sich die beiden Eingabepunkte nicht innerhalb des Dauer-Arguments befinden, wird kein Ausgabewert erzeugt.

Der Standardwert für das Argument Duration ist doppelt der Ausrichtungszeitraum.

`mean_aligner` Führen Sie die Ausrichtung durch, indem Sie den Mittelwert der Werte in einem Fenster ermitteln.

Signatur: ImplicitRowInput mean_aligner([ lit-Duration ] ) → Double.Gauge (implizite Reiheneingabe)

Die Funktion mean_aligner wird für eine Eingabetabelle mit einer einzelnen Wertspalte des numerischen Typs verwendet. (Int oder Double) und Gauge- oder Delta-Zeitachsenart. Sie erzeugt eine Ausgabetabelle mit einer einzelnen Wertspalte des Typs Double und der Zeitachsenart Gauge.

Das Argument Dauer gibt die Breite eines Zeitfensters für jeden Ausgabepunkt an, der zum Zeitpunkt dieses Ausgabepunkts endet. Wenn das Argument Dauer nicht angegeben ist, wird standardmäßig der Ausrichtungszeitraum verwendet. Der Wert eines Ausgabepunktes ist der Mittelwert der Wertpunkte der Eingabetabelle, die in dieses obige Fenster fallen.

`next_older` Angleichung der Zeitpunkte durch Übergang von einer früheren zu einer späteren Zeit.

Signatur: ImplicitRowInput next_older([ lit-Duration ] ) → InputType.Gauge (implizite Reiheneingabe)

Der next_older-Ausrichter wird für Zeitachsen mit einer beliebigen Anzahl von Wertspalten eines beliebigen Typs verwendet, jedoch alle mit dem Zeitachsentyp Gauge. Er erzeugt Ausgabespalten desselben Typs und derselben Art von Zeitachsen.

Der next_older-Ausrichter erstellt einen Ausgabepunkt, indem er den spätestens Eingabepunkt ermittelt, dessen Endzeit nicht später als die Ausgabezeit ist und dessen Endzeit nicht weiter von der Ausgabezeit als das Argument Dauer entfernt ist. Wenn kein solcher Eingabepunkt vorhanden ist, wird kein Ausgabepunkt erstellt.

Der Standardwert für das Argument Duration ist doppelt der Ausrichtungszeitraum.

`next_younger` Angleichung der Zeitpunkte durch Übergang von einer späteren zu einer früheren Zeit.

Signatur: ImplicitRowInput next_younger([ lit-Duration ] ) → InputType.Gauge (implizite Reiheneingabe)

Der next_younger-Ausrichter wird für Zeitachsen mit einer beliebigen Anzahl von Wertspalten eines beliebigen Typs verwendet, jedoch alle mit dem Zeitachsentyp Gauge. Er erzeugt Ausgabespalten desselben Typs und derselben Art von Zeitachsen.

Der next_younger-Ausrichter erstellt einen Ausgabepunkt, indem er den frühesten Eingabepunkt ermittelt, dessen Endzeit nicht früher als die Ausgabezeit ist und dessen Endzeit nicht weiter von der Ausgabezeit als das Argument Dauer entfernt ist. Wenn kein solcher Eingabepunkt vorhanden ist, wird kein Ausgabepunkt erstellt.

Der Standardwert für das Argument Duration ist doppelt der Ausrichtungszeitraum.

Einheiten bearbeiten

Diese Funktionen ändern die Einheiten der Ausdrücke, auf die sie angewendet werden.

`scale` Skaliert einen Wert auf eine andere Maßeinheit.

Signatur: scale(Num, [ lit-String ] ) → Double
scale(Dauer, [ lit-String ] ) → Double
scale(Date, [ lit-String ] ) → Double

Die Funktion scale gibt den Wert des ersten Arguments zurück, gegebenenfalls in Double konvertiert und möglicherweise skaliert, sodass die Einheiten vom zweiten Argument übernommen werden.

Wird kein zweites Argument angegeben, wandelt die Funktion scale das erste Argument nur in Double um, ohne die Einheiten zu ändern. Eine Ausnahme hiervon bilden Fälle, in denen die automatische Skalierung wie hier beschrieben aufgerufen wird. In diesem Fall wird das zweite Argument implizit bereitgestellt und scale verhält sich genauso wie bei zwei Argumenten.

Das zweite Argument muss, falls vorhanden, ein gültiger UCUM-Codestring für die Einheit sein, auf die das erste Argument skaliert werden soll. In diesem Fall bezeichnet der zurückgegebene Wert die gleiche physische Menge wie der Eingabewert, nur in den vom zweiten Argument angegebenen Einheiten ausgedrückt. Dazu wird das Argument mit dem entsprechenden Skalierungsfaktor multipliziert.

Der Ausdruck scale(3 "min", "s") wandelt beispielsweise den Wert 3 mit den Einheiten Minuten (min) in den Wert 180 mit den Einheiten Sekunden (s) um. Derselbe Zeitraum, ausgedrückt in unterschiedlichen Einheiten.

Es ist ein Fehler, wenn das erste Argument keine Einheit hat oder die Einheit des ersten Arguments nicht dieselbe Dimension wie der Einheitencode des zweiten Arguments hat, falls vorhanden. Wenn sie nicht dieselbe Dimension haben, kann das erste Argument nicht skaliert werden, um die Dimension des zweiten Arguments zu erhalten.

Beispiel: Die Angabe von scale(3 "km", "m/s"), was 3 Kilometer auf eine Anzahl an Metern pro Sekunde skalieren möchte, wäre falsch, da Kilometer die Dimension "Distanz" und Meter pro Sekunde die Dimension "Distanz über Zeit" (Geschwindigkeit) hat. Es gibt keinen Skalierungsfaktor, der eine Entfernung in eine Geschwindigkeit umwandeln kann. Man müsste die Entfernung durch einen Wert mit Zeiteinheiten teilen, um dies zu erreichen. Beispiel: scale(3 "km" / 10 "min", "m/s") skaliert .3 "km/min" auf 5 "m/s".

Wenn das erste Argument ein Datums- oder Dauer-Argument ist, muss das zweite Argument eine Zeiteinheit enthalten (z. B. "s", "h" oder "wk"). Der zurückgegebene Wert ist ein Double-Wert, der die Zeit des ersten Argumentwerts in den vom zweiten Argument angegebenen Einheiten angibt. Für einen Datumswert ist dies die Dauer seit der Unix-Epoche.

scale(1m, "s") ergibt beispielsweise den Wert 60.0 mit den Einheiten s, und scale(d'1970/01/01-01:00:00+00', "h") ergibt den Wert 1.0 mit den Einheiten "h" (eine Stunde in die Unix-Epoche hinein).

`cast_units` Setzt die Maßeinheit eines Werts fest.

Signatur: cast_units(Summable, lit-String ) → FirstArgType

Die Funktion cast_units gibt den unveränderten Wert des ersten Arguments zurück, legt die Maßeinheit für diesen Wert so fest, dass die Einheit vom zweiten Argumentstring angegeben wird.

Der String muss ein Wert-UCUM-Codestring für die gewünschte Einheit sein. Jede beliebige Einheit, die das erste Argument hätten haben könnte, bevor das Anwenden dieser Funktion ignoriert wird.

Regelmäßiges Fenster

Die regelmäßigen Fensterfunktionen werden verwendet, um ein tatsächlich übergebenes Dauer-Argument an ein WindowDuration zu annotieren, das eine Fensterbreite angibt, die zur Auswahl von Eingabepunkten für regelmäßige Berechnung verwendet wird. Ein solches Argument wird an den Tabellenvorgang group_by übergeben, der ausgerichtete Zeitachsen ausgibt. Die Funktionen window und sliding beschränken die Breite des Eingabefensters auf den Ausrichtungszeitraum für die Ausgabe.

Die Funktion window gibt an, dass der Ausrichtungszeitraum und die Fensterbreite identisch sein müssen, damit die Eingabepunktfenster nicht überlappen.

Die sliding-Funktion gibt an, dass der Ausrichtungszeitraum kleiner als die Fensterbreite sein kann, wodurch sich Eingabefenster überlappen.

`window` Gibt ein Fenster an, das mit dem Ausrichtungszeitraum übereinstimmt.

Signatur: window([ lit-Duration ] ) → lit-WindowDuration

Die window-Funktion annotiert eine Dauer Das tatsächliche Argument, das an ein WindowDuration-Argument übergeben wird, das eine Fensterbreite angibt, die in einer Berechnung verwendet wird, die ausgerichtete Zeitachsen generiert. Es erfordert, dass die Fensterbreite und der Ausgabeausrichtungszeitraum dem Argument Dauer entsprechen. Wenn das Argument Dauer nicht angegeben ist, gibt die Fensterbreite den Ausrichtungszeitraum für die Ausgabe an, der jedoch definiert ist.

Beispielsweise erzeugt der Tabellenvorgang |group_bywindow(5m), .mean Ausgabepunkte, die dem Mittelwert der Eingabepunkte entsprechen, die innerhalb eines 5 Minuten-Fensters der Ausgabeendzeit liegen. Die window-Funktion annotiert die Fensterbreite 5m, sodass der Ausrichtungszeitraum von group_by ebenfalls 5 Minuten betragen muss. Für den Tabellenvorgang | group_by window(), .mean muss die Fensterbreite ebenfalls mit dem Ausrichtungszeitraum der Ausgabe übereinstimmen, es wird jedoch nicht festgelegt, was das sein muss.

`sliding` Gibt ein Fenster an, das gleitend (überlappt) und nicht disjunkt ist.

Signatur: sliding(lit-Duration ) → lit-SlidingDuration

Die sliding-Funktion annotiert eine Dauer Das tatsächliche Argument, das an ein WindowDuration-Argument übergeben wird, das eine Fensterbreite angibt, die in einer Berechnung verwendet wird, die ausgerichtete Zeitachsen generiert. Die Fensterbreite muss dem Argument Dauer entsprechen und der Ausrichtungszeitraum darf nicht größer sein (darf aber kleiner sein).

Beispielsweise erzeugt der Tabellenvorgang |group_bysliding(5m), .mean Ausgabepunkte, die dem Mittelwert der Eingabepunkte entsprechen, die innerhalb eines 5 Minuten-Fensters der Ausgabeendzeit liegen. Die sliding-Funktion, die die 5m-Fensterbreite annotiert, gibt an, dass der Ausrichtungszeitraum von group_by nicht länger als 5 Minuten sein darf. Wenn ein | every 1m-Tabellenvorgang eine 1-Minuten-Ausrichtung angibt, überlappen die 4 Minuten jedes 5-Minuten-Fensters das Fenster des nächst früheren Ausgabepunkts.

Vertrieb

`count_from` Die Anzahl der Werte in einem Verteilungswert.

Signatur: count_from(Distribution.CumulativeOK ) → Int.FirstArgKind

Die count_from-Funktion gibt die Größe der Population von Werten im eingegebenen Verteilungswert zurück.

Die mit dem Ergebnis von count_from verbundene Maßeinheit ist 1.

`sum_from` Die Summe der Werte in einem Verteilungswert.

Signatur: sum_from(Distribution.CumulativeOK ) → Double.FirstArgKind

Die Funktion sum_from gibt die Summe aller Werte zurück, die in ihrem Eingabeverteilungswert enthalten sind.

Das Ergebnis von sum_from hat dieselbe Maßeinheit wie die Eingabe.

`mean_from` Der Mittelwert der Werte in einem Verteilungswert.

Signatur: mean_from(Verteilung ) → Double

Die Funktion mean_from gibt das arithmetische Mittel aller Werte zurück, die in ihrem Eingabeverteilungswert enthalten sind.

Das Ergebnis von mean_from hat dieselbe Maßeinheit wie die Eingabe.

`stddev_from` Die Standardabweichung der Werte in einem Verteilungswert.

Signatur: stddev_from(Verteilung ) → Double

Die Funktion stddev_from gibt die Varianz der Gesamtheit der Werte zurück, die in ihrem Eingabeverteilungswert enthalten sind.

Das Ergebnis von stddev_from hat dieselbe Maßeinheit wie die Eingabe.

`variance_from` Die Varianz der Werte in einem Verteilungswert.

Signatur: variance_from(Verteilung ) → Double

Die Funktion variance_from gibt die Varianz der Gesamtheit der Werte zurück, die in ihrem Eingabeverteilungswert enthalten sind.

Das Ergebnis der Funktion "variance_from" hat keine Maßeinheit.

`median_from` Der Mittelwert der Werte in einem Verteilungswert.

Signatur: median_from(Verteilung ) → Double

Die median_from-Funktion gibt eine Schätzung des Medianwerts der Gesamtheit der Werte zurück, die in ihrem Eingabeverteilungswert enthalten sind.

Das Ergebnis von median_from hat dieselbe Maßeinheit wie die Eingabe.

`percentile_from` Ein Perzentil der Werte in einem Verteilungswert.

Signatur: percentile_from(Verteilung, lit-Num ) → Double

Die percentile_from-Funktion gibt eine Schätzung des Perzentils der Gesamtheit der Werte zurück, die in ihrem Eingabeverteilungswert enthalten sind. Das Argument Num gibt das Perzentil an, das als Zahl zwischen 0 und 100 schätzen wird.

Das Ergebnis von percentile_from hat dieselbe Maßeinheit wie die Eingabe.

`fraction_less_than_from` Der Anteil der Werte in einer Verteilung, die kleiner als ein fester Wert sind.

Signatur: fraction_less_than_from(Verteilung, lit-Num ) → Double

Die fraction_less_than_from-Funktion gibt eine Schätzung des Populationsanteils der in ihrem Eingabeverteilungswert enthaltenen Werte zurück, die kleiner als ihr Num-Argument sind.

Die mit dem Ergebnis von fraction_less_than verbundene Maßeinheit ist 10^2.%.

`bounded_percentile_from` Ein Perzentil der Werte innerhalb einer Grenze in einem Verteilungswert.

Signatur: bounded_percentile_from(Verteilung, lit-Num, [ lit-Num ], [ lit-Num ] ) → Double

Die Funktion bounded_percentile_from wird für eine Teilmenge des in der Eingabeverteilung enthaltenen Werts ausgeführt. Es wird eine Schätzung der Grundgesamtheit der Werte vorgenommen, die größer als der zweite Num-Parameter, falls angegeben, und kleiner oder gleich dem dritten Num-Parameter, falls angegeben, sind. Es muss mindestens eines der Num-Argumente für das zweite und dritte Argument angegeben werden. Wenn beide Argumente angegeben sind, muss das zweite Argument kleiner als das dritte sein.

Dies gibt eine Schätzung des Perzentils dieser geschätzten Wertepopulation zurück. Das erste Num-Argument gibt das zu schätzende Perzentil als Zahl zwischen 0 und 100 an.

Das Ergebnis von bounded_percentile_from hat dieselbe Maßeinheit wie die Eingabe.

`rebucket` Verteilungswert, der in eine neue Bucket-Spezifikation umgewandelt wurde

Signatur: rebucket(Verteilung, lit-BucketSpecification ) → Verteilung

Dadurch wird der eingegebene Verteilungswert in einen Verteilungswert umgewandelt, dessen Bucket-Spezifikation die im zweiten Argument BucketSpecification angegebene ist.

Dadurch werden die Zählungen von jedem Bucket in der Eingabeverteilung auf die Buckets der Ausgabeverteilung unter der Annahme verteilt, dass die in einem Bucket gezählten Werte gleichmäßig über den Bereich des Buckets verteilt sind. Die Ausgabeverteilung hat die gleiche Gesamtzahl wie die Eingabeverteilung, aber die Anzahl wird anders auf die Ausgabe-Distributions-Buckets verteilt. Die Ausgabeverteilung hat dieselbe Summe, denselben Mittelwert und dieselbe Standardabweichung wie die Eingabeverteilung.

Bucket-Spezifizierer

Ein Verteilungswert hat ein Histogramm, das aus Buckets besteht. Jeder Bucket ist einem Wertebereich zugeordnet und enthält die Anzahl der Werte in der Verteilung, die in diesen Bereich fallen. Jede Verteilung hat eine Bucket-Spezifikation, die die Grenzen für die Buckets in einem Verteilungswert beschreibt. Die Funktionen in diesem Abschnitt generieren Bucket-Spezifikationen.

`powers_of` Eine Bucket-Spezifikation mit exponentiell zunehmenden Bucket-Grenzen.

Signatur: powers_of(lit-Num ) → lit-BucketSpecification

Die Funktion powers_of gibt eine Bucket-Spezifikation zurück, bei der die Obergrenze jedes Buckets ein fester Faktor (gegeben durch das Num-Argument) mal der Untergrenze ist. Daher ist die Bucket-Größe exponentiell zu, und der Fehler bei der Berechnung der Perzentile wird durch einen konstanten Faktor des wahren Werts begrenzt.

Dadurch wird weder die Anzahl der Buckets noch die Untergrenze des ersten Buckets festgelegt, die entweder durch "num_buckets" und "lower" angegeben werden müssen, oder es werden die Standardwerte (30 Buckets, Untergrenze von 1,0) verwendet. Wenn die Bucket-Spezifikation von powers_of angegeben wird, muss die Untergrenze größer als 0 sein.

Im folgenden Beispiel wird eine Bucket-Spezifikation mit 50 Buckets zugewiesen, deren Größe exponentiell mit einer Rate von 1,1 steigt, beginnend bei 100. Die Bucket-Grenzen lauten also 1, 1,1, 1,21, 1.331 usw.

powers_of(1.1).num_buckets(30).lower(100.0)

`fixed_width` Eine Bucket-Spezifikation mit gleich großen Buckets.

Signatur: fixed_width(lit-Num ) → lit-BucketSpecification

Die fixed_width-Funktion gibt eine Bucket-Spezifikation zurück, bei der die Obergrenze jedes Buckets (festgelegt durch das Argument Num) größer als die Untergrenze ist. Daher ist die Bucket-Größe fest.

Im folgenden Beispiel wird eine Bucket-Spezifikation mit 100 Buckets der Größe 1 vergeben, die mit 1 markiert ist. Dies ist eine gute Spezifikation für eine Verteilung von Prozentwerten.

fixed_width(1).num_buckets(100)

`custom` Eine Bucket-Spezifikation aus einer Liste von Bucket-Grenzen.

Signatur: custom(lit-Num... ) → lit-BucketSpecification

Die Funktion custom gibt eine Bucket-Spezifikation mit explizit angegebenen Bucket-Grenzen zurück. Die Funktion akzeptiert mehrere numerische Argumente, die in aufsteigender Reihenfolge angegeben werden müssen. Die Untergrenze des ersten Buckets wird durch das erste Argument und die Obergrenze des letzten Buckets durch das letzte Argument angegeben. Jedes Zwischenargument gibt die Obergrenze des vorherigen Buckets und die Obergrenze des nächsten Buckets an.

Dadurch wird die Bucket-Spezifikation vollständig bestimmt, d. h. die Anzahl der Buckets und die genaue Grenze jedes Buckets.

Im folgenden Beispiel wird eine Bucket-Spezifikation mit drei Buckets angegeben. Die erste hat die Grenzen 3 und 27, die zweite 27 und 105 und die dritte 105 und 277.

custom(3,27,105,277)

`num_buckets` Legt die Anzahl der Buckets in einer Bucket-Spezifikation fest.

Signatur: num_buckets(lit-BucketSpecification, lit-Num ) → lit-BucketSpecification

Bei Anwendung auf eine Bucket-Spezifikation, die nicht über die ermittelte Anzahl von Buckets verfügt, gibt die Funktion num_buckets eine Bucket-Spezifikation mit einer Anzahl von Buckets zurück, die durch das Argument Num angegeben wird. Alle anderen Aspekte der Eingabe-Bucket-Spezifikation bleiben erhalten.

Es ist ein Fehler, num_buckets auf eine Bucket-Spezifikation anzuwenden, für die bereits die Anzahl der ermittelten Buckets festgelegt ist.

`bounds` Legt die Untergrenze des ersten Buckets und die Obergrenze des letzten fest.

Signatur: bounds(lit-BucketSpecification, lit-Num, lit-Num ) → lit-BucketSpecification

Bei Anwendung auf eine Bucket-Spezifikation, bei der weder die Untergrenze des ersten Buckets noch die Obergrenze des letzten Buckets ermittelt wurde, gibt die bounds-Funktion eine Bucket-Spezifikation zurück, bei der die Untergrenze des ersten Buckets durch das erste Num-Argument und die Obergrenze des letzten Buckets durch das zweite Num-Argument gegeben ist. Alle anderen Aspekte der Eingabe-Bucket-Spezifikation bleiben erhalten.

Es ist ein Fehler, bounds auf eine Bucket-Spezifikation anzuwenden, für die bereits die Untergrenze des ersten Buckets oder die Obergrenze des zuletzt ermittelten Buckets festgelegt ist.

`lower` Legt die Untergrenze des ersten Buckets in einer Bucket-Spezifikation fest.

Signatur: lower(lit-BucketSpecification, lit-Num ) → lit-BucketSpecification

Bei Anwendung auf eine Bucket-Spezifikation, bei der die Untergrenze des ersten Buckets nicht bestimmt wurde, gibt die Funktion num_buckets eine Bucket-Spezifikation zurück, bei der die Untergrenze des ersten Buckets durch das Num-Argument gegeben ist. Alle anderen Aspekte der Eingabe-Bucket-Spezifikation bleiben erhalten.

Wenn Sie lower auf eine Bucket-Spezifikation anwenden, die bereits die Untergrenze des ersten Buckets hat, ist es ein Fehler.

Sonstiges

`cast_double` Int-Wert in Double umwandeln.

Signatur: cast_double(Num.CumulativeOK ) → Double.FirstArgKind

Die cast_double-Funktion verwendet ein einzelnes Int-Argument und gibt den nächsten Double-Wert zurück.

Das Ergebnis von cast_double hat dieselbe Maßeinheit wie die Eingabe.

`cast_gauge` Einen kumulativen oder Delta-Zeitachsenwert in Gauge umwandeln.

Signatur: cast_gauge(ColumnValue.CumulativeOK ) → FirstArgType.Gauge

Die cast_gauge-Funktionen geben den Wert ihres Arguments zurück, ändern jedoch den Zeitachsentyp des Werts in Gauge.

Wenn dies zu einer Ausgabetabelle ohne Wertspalten mit dem Zeitachsentyp Delta führt, enthält die Ausgabetabelle keine Startzeitspalte.

Das Ergebnis von cast_gauge hat dieselbe Maßeinheit wie die Eingabe.

`within` Gibt das Fenster der Sortierwertberechnung an.

Signatur: within(ColumnValue, [ lit-DateOrDuration ], [ lit-DateOrDuration ] ) → Windowed.FirstArgKind

Die within-Funktion dekoriert den an das Windowed(Num)-Sortierwertargument gebundenen Ausdruck des top- oder bottom-Tabellenvorgangs. Sie gibt das Fenster an, in dem der Sortierwertausdruck ausgewertet wird, indem einer oder zwei von drei Werten angegeben werden: die älteste (Start-)Zeit des Fensters, die jüngste (End-)Zeit des Fensters oder die Dauer des Fensters.

Wenn eines der beiden Argumente von within eine positive Dauer ist, wird die Breite des Fensters festgelegt. Es kann höchstens eines der Argumente eine solche Dauer sein.

Wenn das erste Argument ein Date ist, wird die Startzeit angegeben. Wenn das zweite Argument ein Date ist, wird die Endzeit angegeben. Wenn beide Date-Werte sind, muss der zweite Wert zeitlich später als der erste sein. Ein Date-Argument kann als Date-Literal oder mit einem negativen Dauer-Literal angegeben werden. Im zweiten Fall ist die Zeit die angegebene Dauer vor der Endzeit des äußeren Abfragefensters (siehe within-Tabellenvorgang).

Wenn das erste Argument nicht angegeben wird, wird standardmäßig die Startzeit des äußeren Abfragefensters verwendet. Wenn das zweite Argument nicht angegeben wird, wird standardmäßig die Endzeit des äußersten Abfragefensters verwendet.

.mean().within(1h,-2h) gibt beispielsweise an, dass der Reducer max auf alle Punkte in der Eingabezeitachse angewendet werden soll, deren Endzeit innerhalb eines Fensters mit einer Breite von 1 Stunde und der Beendigung von zwei Stunden liegt. Der Aggregator mean wird auf alle Eingabepunkte angewendet, deren Endzeit in diesem Fenster liegt.

Beispiel: max(val()).within(10m) gibt an, dass der max-Reducer auf alle Punkte in der Eingabezeitachse angewendet werden soll, deren Endzeit in die Zeitraum fällt zwischen der Abfrageendzeit und 10 Minuten früher liegt. Der Aggregator max wird auf alle Eingabepunkte angewendet, deren Endzeit in diesem Fenster liegt.

Index der Tabellenvorgänge und -funktionen

Es folgt ein Index aller Tabellenvorgänge und -funktionen.

abs Absoluter Wert.
absent_for Bedingung für das Fehlen einer Eingabe erstellen.
add Die Summe zweier Zahlen.
adjacent_delta Die Wertänderung zwischen einem Eingabepunkt und dem nächst früheren Punkt.
adjacent_rate Die Änderungsrate zwischen den Eingaben und den nächsten früheren Punkten (Zeilen).
aggregate Der Standardaggregatwert aus einer Gruppe von Werten eines beliebigen Typs
align Erzeugt eine ausgerichtete Tabelle mithilfe einer Ausrichtungsfunktion.
all_true Die Verknüpfung einer Gruppe von booleschen Werten.
and Das logische "und" von zwei booleschen Werten.
any_true Die Disjunktion einer Gruppe von booleschen Werten.
any_true_aligner Richten Sie eine Bool-Zeitachse aus, indem Sie einen echten Wert in einem Fenster finden.
ascii_to_lower ASCII-Großbuchstaben in Kleinbuchstaben ändern.
ascii_to_upper ASCII-Kleinbuchstaben in Großbuchstaben ändern.
bottom Unterste Zeitachse nach einem Sortierwertausdruck auswählen.
bottom_by Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.
bounded_percentile_from Ein Perzentil der Werte innerhalb einer Grenze in einem Verteilungswert.
bounds Untergrenze des ersten Buckets und Obergrenze des letzten Buckets festlegen.
cast_double Int-Wert in Double umwandeln.
cast_gauge Einen kumulativen oder Delta-Zeitachsenwert in Gauge umwandeln.
cast_units Setzt die Maßeinheit eines Werts fest.
concatenate String-Verkettung.
condition Der Eingabetabelle eine boolesche Bedingungsspalte hinzufügen.
count Die Anzahl der Werte in einer Gruppe von Werten.
count_from Die Anzahl der Werte in einem Verteilungswert.
count_true Die Anzahl der wahren Werte in einer Gruppe boolescher Werte.
count_true_aligner Richten Sie eine Bool-Zeitachse aus, indem Sie die wahren Werte in einem Fenster zählen.
covariance Die Kovarianz einer Gruppe von Wertenpaaren.
custom Eine Bucket-Spezifikation aus einer Liste von Bucket-Grenzen.
delta Wertänderung zu ausgerichteten Zeitpunkten berechnen.
delta_gauge Wertänderung zu ausgerichteten Zeitpunkten als Gauge Zeitachse berechnen.
diameter Das Maximum plus das Minimum einer Gruppe numerischer Werte.
distribution Eine Verteilung aus einer Gruppe von numerischen Werten oder Verteilungswerten.
div Das Verhältnis zweier Zahlen.
end Die Endzeit des Eingabepunkts (Zeile).
eq Gleich.
every Zeitraum für die Ausgabe der ausgerichteten Tabelle angeben.
exp Potenziertes e.
false Der boolesche Wert "false"
fetch Erstellt eine Tabelle aus der Datenbank.
fetch_cumulative Erstellt eine Tabelle mit kumulativen Zeitachsen aus der Datenbank.
filter Filtert Zeilen aus einer Eingabetabelle anhand eines Prädikats.
filter_ratio Berechnet das Verhältnis zweier gefilterter Summen der Eingabewertspalte.
filter_ratio_by berechnet ein gruppiertes Verhältnis von zwei gefilterten Summenwerten der Spalte mit den Eingabewerten.
fixed_width Eine Bucket-Spezifikation mit gleich großen Buckets.
fraction_less_than Der Bruchteil einer Gruppe von Werten, die kleiner als ein fester Wert sind.
fraction_less_than_from Der Bruchteil der Werte in einer Verteilung, die kleiner als ein fester Wert sind
fraction_true Der Anteil einer Gruppe boolescher Werte, die wahr sind.
fraction_true_aligner Richten Sie eine Bool-Zeitachse mit dem Anteil der tatsächlichen Werte in einem Fenster aus.
ge Größer als oder gleich.
graph_period Gibt den bevorzugten Ausgabezeitraum zum Zeichnen von Zeitachsengrafiken an.
group_by Fasst Zeilen nach zugeordneter Zeitachsenkennzeichnung und Zeitfenster zusammen.
gt Größer als.
has "True", wenn ein Mengenargument einen bestimmten Wert enthält.
has_value "True", wenn ein Argumentausdruck einen Wert berechnet.
hash_tsid Gibt einen Hash der Spalten der Zeitachsenkennzeichnung zurück.
ident Identitätstabellenvorgang: keine Änderung an der Eingabetabelle.
if Ein Wert, der auf Basis einer Bedingung aus zwei Werten ausgewählt wird
int_ceil Ganzzahl der Obergrenze.
int_div Der Quotient aus der Teilung zweier Ganzzahlen.
int_floor Ganzzahl der Untergrenze.
int_mean_aligner Führen Sie die Ausrichtung durch, indem Sie den Mittelwert von Int-Werten in einem Fenster ermitteln.
int_round Nächste ganze Zahl.
interpolate Interpolierte Werte zu ausgerichteten Zeitpunkten berechnen.
join Natural Join mehrerer Tabellen.
le Kleiner als oder gleich.
log Natürlicher Logarithmus.
lower Legt die Untergrenze des ersten Buckets in einer Bucket-Spezifikation fest.
lt Kleiner als.
map Schreibt die Zeitachsenkennzeichnungs- und wertspalten jeder Zeile in einer Tabelle neu.
max: Das Maximum einer Gruppe numerischer Werte
mean Der Mittelwert einer Gruppe numerischer Werte.
mean_aligner Gleichen Sie den Mittelwert der Werte in einem Fenster ab.
mean_from Der Mittelwert der Werte in einem Verteilungswert.
median Der Mittelwert einer Gruppe numerischer Werte oder Verteilungswerte.
median_from Der Mittelwert der Werte in einem Verteilungswert.
metric Erstellt die Tabelle für einen bestimmten Messwerttyp aus einer Reihe von Tabellen.
min Minimum einer Gruppe numerischer Werte.
mul Das Produkt zweier Zahlen.
ne Ungleich.
neg Der negative Wert einer Zahl.
next_older Angleichung der Zeitpunkte durch Übergang von einer früheren zu einer späteren Zeit.
next_younger Angleichung der Zeitpunkte durch Übergang von einer späteren zu einer früheren Zeit.
not Die logische Negation eines booleschen Werts.
num_buckets Legt die Anzahl der Buckets in einer Bucket-Spezifikation fest.
older Ein Wert aus dem nächsten früheren Punkt (Zeile) in einer Zeitachse.
or Das logische "oder" von zwei booleschen Werten.
or_else Ein Wert oder, wenn es sich nicht um einen Wert handelt, ein anderer Wert.
outer_join Äußeres Natural Join zweier Tabellen.
percentile Ein Perzentil einer Gruppe von numerischen Werten oder Verteilungswerten.
percentile_from Ein Perzentil der Werte in einem Verteilungswert.
pick_any Der Wert eines beliebigen Elements einer Gruppe von Werten (beliebig gewählt).
pos Identität für numerische Eingaben.
power Eine Zahl potenziert zu einer anderen Zahl.
powers_of Eine Bucket-Spezifikation mit exponentiell zunehmenden Bucket-Grenzen.
rate Die Änderungsrate zu ausgerichteten Zeitpunkten berechnen.
ratio Das Verhältnis der Wertspalten von zwei ausgerichteten Eingabetabellen berechnen.
re_extract Werte extrahieren, die mit einem regulären Ausdruck in einem anderen String übereinstimmen.
re_full_match Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.
re_global_replace Ersetzt alle Übereinstimmungen eines regulären Ausdrucks in einem anderen String.
re_partial_match Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.
re_replace Ersetzen Sie die erste Übereinstimmung eines regulären Ausdrucks in einem anderen String.
rebucket Der in eine neue Bucket-Spezifikation konvertierte Verteilungswert.
rem Der Rest der Division von zwei Ganzzahlen.
row_count Die Anzahl der gefundenen Eingabezeilen.
scale Skaliert einen Wert auf eine andere Maßeinheit.
singleton Der Wert des Elements einer Gruppe von Werten mit nur einem Element.
sliding Gibt ein Fenster an, das gleitend (überlappt) und nicht disjunkt ist.
sqrt Quadratwurzel.
start Die Startzeit des Eingabepunkts (Zeile).
stddev Die Standardabweichung einer Gruppe von Werten.
stddev_from Die Standardabweichung der Werte in einem Verteilungswert.
string_to_double String in Double umwandeln.
string_to_int64 String in Int umwandeln.
sub Die Differenz zweier Zahlen.
sum Die Summe einer Gruppe numerischer Werte.
sum_from Die Summe der Werte in einem Verteilungswert.
time_shift Zeitachsen zeitlich vorwärts verschieben.
top Wählt die oberste Zeitachse nach einem Sortierwertausdruck aus.
top_by Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.
true Der boolesche Wert "wahr".
unaligned_group_by Aggregiert Zeilen nach der zugeordneten Zeitachsenkennzeichnung ohne Ausrichtung.
union Union mehrerer Tabellen.
union_group_by Aggregiert Zeilen aus mehreren Tabellen.
unique Der gemeinsame Wert einer Gruppe von Werten (die alle gleich sein müssen).
utf8_normalize Unicode-String, der sich für den Vergleich der Groß-/Kleinschreibung eignet.
val Der Wert einer Wertspalte im Eingabepunkt (Zeile).
valueSchreibt die Wertspalten jeder Zeile in einer Tabelle neu.
variance Die Varianz einer Gruppe von numerischen Werten.
variance_from Die Varianz der Werte in einem Verteilungswert.
weighted_distribution Eine Verteilung aus einer Gruppe gewichteter Werte.
window Gibt ein Fenster an, das dem Ausrichtungszeitraum entspricht.
window Gibt das Fenster für Ausrichtungsvorgänge an.
within Gibt das Fenster der Sortierwertberechnung an.
within Gibt den Zeitraum der Abfrageausgabe an.

Referenz zur Monitoring-Abfragesprache

Datenmodell

Zeitachse

Tabellen

Metadata

Ausrichtung

Syntax und Semantik

Lexikalische Elemente

Abfragestruktur

Tabellennamen

Ausdrücke

Maps

Maßeinheiten

Kurzformen für Tabellenvorgänge

Tabellenvorgänge und Funktionsbeschreibungen

Tabellenvorgänge

Abrufen

fetch Erstellt eine Tabelle aus der Datenbank.

metric Erstellt die Tabelle für einen bestimmten Messwerttyp aus einer Reihe von Tabellen.

fetch_cumulative Erstellt eine Tabelle mit kumulativen Zeitachsen aus der Datenbank.

Auswahl

filter Filtert Zeilen aus einer Eingabetabelle anhand eines Prädikats.

top Wählt die oberste Zeitachse nach einem Sortierwertausdruck aus.

bottom Unterste Zeitachse nach einem Sortierwertausdruck auswählen.

top_by Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.

bottom_by Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.

Zeilenänderung

map Schreibt die Zeitachsenkennzeichnungs- und Wertspalten jeder Zeile in einer Tabelle neu.

value Schreibt die Wertspalten jeder Zeile in einer Tabelle neu.

time_shift Zeitachsen vorwärts verschieben.

Zeitachsenausrichtung

align Erstellt eine ausgerichtete Tabelle mithilfe einer Ausrichtungsfunktion.

Aggregation

group_by Fasst Zeilen nach zugeordneter Zeitachsenkennzeichnung und Zeitfenster zusammen.

union_group_by Aggregiert Zeilen aus mehreren Tabellen.

unaligned_group_by Aggregiert Zeilen nach zugeordneter Zeitachsenkennzeichnung ohne Ausrichtung.

Union und Join

join Natural Join von mehreren Tabellen

outer_join Äußeres Natural Join zweier Tabellen.

union Union mehrerer Tabellen.

Zeithorizont und Zeitraum

every Gibt den Zeitraum für die ausgerichtete Tabellenausgabe an

within Gibt den Zeitraum der Abfrageausgabe an.

graph_period Gibt den bevorzugten Ausgabezeitraum zum Zeichnen von Zeitachsengrafiken an.

window Gibt das Fenster für Ausrichtungsvorgänge an.

Benachrichtigungen

condition Der Eingabetabelle eine boolesche Bedingungsspalte hinzufügen.

absent_for Bedingung für das Fehlen einer Eingabe erstellen.

Sonstiges

ident Identitätstabellenvorgang: Keine Änderung an der Eingabetabelle

ratio Das Verhältnis der Wertspalten von zwei ausgerichteten Eingabetabellen berechnen.

filter_ratio Berechnet das Verhältnis zweier gefilterter Summen der Eingabewertspalte.

filter_ratio_by Berechnet ein gruppiertes Verhältnis von zwei gefilterten Summen der Eingabewertspalte.

Functions

Eingabezeilenspalten

val Der Wert einer Wertspalte im Eingabepunkt (Zeile).

end Die Endzeit des Eingabepunkts (Zeile).

start Die Startzeit des Eingabepunkts (Zeile).

older Ein Wert aus dem nächst früheren Punkt (Zeile) in einer Zeitachse.

adjacent_delta Die Wertänderung zwischen einem Eingabepunkt und dem nächst früheren Punkt.

adjacent_rate Die Änderungsrate zwischen der Eingabe und den nächsten früheren Punkten (Zeilen).

hash_tsid Gibt einen Hash der Spalten der Zeitachsenkennzeichnung zurück.

Logisch

not Die logische Negation eines booleschen Werts.

and Das logische "and" von zwei booleschen Werten.

or Das logische "oder" von zwei booleschen Werten.

true Der boolesche Wert "true".

false Der boolesche Wert "false".

has "True", wenn ein Set-Argument einen bestimmten Wert enthält.

has_value "True", wenn ein Argumentausdruck einen Wert berechnet.

if Ein Wert, der aus zwei Werten ausgewählt wurde.

or_else Ein Wert oder, falls es sich um keinen Wert handelt, ein anderer Wert.

Vergleich

eq Gleich.

ne Ungleich.

ge Größer als oder gleich.

gt Größer als.

le Kleiner als oder gleich.

lt Weniger als.

Arithmetisch

`fetch` Erstellt eine Tabelle aus der Datenbank.

`metric` Erstellt die Tabelle für einen bestimmten Messwerttyp aus einer Reihe von Tabellen.

`fetch_cumulative` Erstellt eine Tabelle mit kumulativen Zeitachsen aus der Datenbank.

`filter` Filtert Zeilen aus einer Eingabetabelle anhand eines Prädikats.

`top` Wählt die oberste Zeitachse nach einem Sortierwertausdruck aus.

`bottom` Unterste Zeitachse nach einem Sortierwertausdruck auswählen.

`top_by` Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.

`bottom_by` Zeitachsen nach einem Sortierwertausdruck in verschiedenen Gruppen auswählen.

`map` Schreibt die Zeitachsenkennzeichnungs- und Wertspalten jeder Zeile in einer Tabelle neu.

`value` Schreibt die Wertspalten jeder Zeile in einer Tabelle neu.

`time_shift` Zeitachsen vorwärts verschieben.

`align` Erstellt eine ausgerichtete Tabelle mithilfe einer Ausrichtungsfunktion.

`group_by` Fasst Zeilen nach zugeordneter Zeitachsenkennzeichnung und Zeitfenster zusammen.

`union_group_by` Aggregiert Zeilen aus mehreren Tabellen.

`unaligned_group_by` Aggregiert Zeilen nach zugeordneter Zeitachsenkennzeichnung ohne Ausrichtung.

`join` Natural Join von mehreren Tabellen

`outer_join` Äußeres Natural Join zweier Tabellen.

`union` Union mehrerer Tabellen.

`every` Gibt den Zeitraum für die ausgerichtete Tabellenausgabe an

`within` Gibt den Zeitraum der Abfrageausgabe an.

`graph_period` Gibt den bevorzugten Ausgabezeitraum zum Zeichnen von Zeitachsengrafiken an.

`window` Gibt das Fenster für Ausrichtungsvorgänge an.

`condition` Der Eingabetabelle eine boolesche Bedingungsspalte hinzufügen.

`absent_for` Bedingung für das Fehlen einer Eingabe erstellen.

`ident` Identitätstabellenvorgang: Keine Änderung an der Eingabetabelle

`ratio` Das Verhältnis der Wertspalten von zwei ausgerichteten Eingabetabellen berechnen.

`filter_ratio` Berechnet das Verhältnis zweier gefilterter Summen der Eingabewertspalte.

`filter_ratio_by` Berechnet ein gruppiertes Verhältnis von zwei gefilterten Summen der Eingabewertspalte.

`val` Der Wert einer Wertspalte im Eingabepunkt (Zeile).

`end` Die Endzeit des Eingabepunkts (Zeile).

`start` Die Startzeit des Eingabepunkts (Zeile).

`older` Ein Wert aus dem nächst früheren Punkt (Zeile) in einer Zeitachse.

`adjacent_delta` Die Wertänderung zwischen einem Eingabepunkt und dem nächst früheren Punkt.

`adjacent_rate` Die Änderungsrate zwischen der Eingabe und den nächsten früheren Punkten (Zeilen).

`hash_tsid` Gibt einen Hash der Spalten der Zeitachsenkennzeichnung zurück.

`not` Die logische Negation eines booleschen Werts.

`and` Das logische "and" von zwei booleschen Werten.

`or` Das logische "oder" von zwei booleschen Werten.

`true` Der boolesche Wert "true".

`false` Der boolesche Wert "false".

`has` "True", wenn ein Set-Argument einen bestimmten Wert enthält.

`has_value` "True", wenn ein Argumentausdruck einen Wert berechnet.

`if` Ein Wert, der aus zwei Werten ausgewählt wurde.

`or_else` Ein Wert oder, falls es sich um keinen Wert handelt, ein anderer Wert.

`eq` Gleich.

`ne` Ungleich.

`ge` Größer als oder gleich.

`gt` Größer als.

`le` Kleiner als oder gleich.

`lt` Weniger als.

`add` Die Summe zweier Zahlen.

`sub` Die Differenz zweier Zahlen.

`mul` Das Produkt zweier Zahlen.

`div` Das Verhältnis zweier Zahlen.

`int_div` Der Quotient aus der Teilung zweier Ganzzahlen.

`abs` Absoluter Wert.

`neg` Der negative Wert einer Zahl.

`pos` Identität für numerische Eingaben.

`rem` Der Rest der Teilung zweier Ganzzahlen.

`sqrt` Quadratwurzel.

`log` Natürlicher Logarithmus.

`exp` Potenziertes e.

`power` Eine Zahl potenziert zu einer anderen Zahl.

`int_round` Nächste ganze Zahl.

`int_floor` Ganzzahl der Untergrenze.

`int_ceil` Ganzzahl der Obergrenze.

`concatenate` String-Verkettung.

`string_to_double` String in Double umwandeln.

`string_to_int64` String in Int umwandeln.

`ascii_to_lower` ASCII-Großbuchstaben in Kleinbuchstaben ändern.

`ascii_to_upper` Ändern der ASCII-Kleinbuchstaben in Großbuchstaben.

`utf8_normalize` Unicode-String, der sich für den Vergleich der Groß-/Kleinschreibung eignet.

`re_full_match` Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.

`re_partial_match` Wahr, wenn ein regulärer Ausdruck mit einem Stringwert teilweise übereinstimmt.

`re_extract` Werte extrahieren, die mit einem regulären Ausdruck in einem anderen String übereinstimmen.

`re_replace` Ersetzt die erste Übereinstimmung eines regulären Ausdrucks in einem anderen String.

`re_global_replace` Ersetzt alle Übereinstimmungen eines regulären Ausdrucks in einem anderen String.

`sum` Die Summe einer Gruppe numerischer Werte.

`distribution` Eine Verteilung aus einer Gruppe numerischer Werte oder Verteilungswerte.

`count` Die Anzahl der Werte in einer Gruppe von Werten.