Azure Time Series Insights Gen1-frågesyntax

Varning

Det här är en Gen1-artikel.

Den här artikeln beskriver frågeförfrågans format och syntax för Azure Time Series Insights Gen1 Query API.

Sammanfattning

Viktigt

• Frågebegäranden måste vara i JSON-format.
• HTTP-begärandenyttolaster som görs till fråge-API :et bör överensstämma med det format som anges i den här artikeln.

Språket delas in i följande element:

• Skalära uttryck som producerar skalära värden. Skalära uttryck inkluderar predikatstränguttryck, jämförelseuttryck och aritmetiska uttryck.
• Skalärfunktioner som returnerar skalära värden.
• Aggregerade uttryck som används för att partitionera samlingar av händelser och beräkningsmått över partitionerna.
• Satser, som utgör komponenterna i JSON-frågor eller en del av ett uttryck.

Datamodell

Azure Time Series Insights Gen1 Query-API:et fungerar på data som lagras som enskilda händelser i en miljö. Varje händelse är en uppsättning egenskapsnamn och värdepar .

Händelseegenskaper

Händelseegenskaper kan vara av någon av följande primitiva typer: Bool, DateTime, Double eller String. Alla primitiva typer kan inte användas.

Anteckning

Anpassade format för händelsekällor kan ha stöd för en större uppsättning värdetyper. Azure Time Series Insights Gen1 härleder den närmaste primitiva typen och omvandlar sedan anpassade typer till dem vid ingress.

Alla händelser har följande inbyggda egenskaper med ett fördefinierat namn och typ:

Egenskapsnamn	Egenskapstyp	Definition
$ts	DateTime	Tidsstämpel för händelser
$esn	Sträng	Händelsekällans namn

• Tidsstämpel för händelser

  Som standard tillhandahålls ett händelsetidsstämpelvärde av händelsekällan. Händelser som kommer från en IoT-hubb skulle till exempel ha sin tid som tidsstämpel.

  Kunder kan ändra det här beteendet genom att konfigurera en annan händelseegenskap i stället. Anpassade tidsstämpelegenskaper kan anges i händelsehubbar och IoT-hubbar.

• Händelsekällans namn

  Händelsekällans namn är det namn som visas för den händelsekälla som Azure Time Series Insights Gen1 har tagit emot händelsen från. Händelsekällans namn är associerade med en viss händelse vid ingresstiden.

  Viktigt

  • Händelsekällans namn förblir oförändrade under händelsens livslängd.
  • Om namnet på en händelsekälla ändras bär befintliga händelser det gamla händelsekällans namn. Nya händelser kommer att innehålla det nya händelsekällans namn.

Händelsetyper

Anpassade händelseegenskaper identifieras och refereras unikt i frågeuttryck efter namn och typ. En händelse kan ha fler än en egenskap med samma namn och olika typer. Egenskaper med samma namn men olika typer kan bero på ingresstypsdelning.

Ett händelseegenskapsvärde av strängtyp kan lagras som en egenskap med en annan typ i följande fall:

• Om ett Strängvärde är ett giltigt Double-värde lagras det både som Double och String.
• Om ett Strängvärde är ett giltigt DateTime-värde lagras det endast som DateTime .

Fråge-API:et konverterar tomma Strings-literaler ("") till null i utdata.

Azure Time Series Insights Gen1 har begränsat stöd för följande värden inom typen Double: Double.NaN, Double.PositiveInfinityoch Double.NegativeInfinity. Dessa värden konverteras till null under ingressen, men om frågeutvärderingen genererar något av dessa värden utvärderas och serialiseras värdet som en sträng som svar.

Du kan skicka dessa värden som Strängar för ingress, så i frågeuttryck bör dessa värden också skickas som strängar.

Händelsescheman beskriver egenskaperna för en händelse. Ett händelseschema innehåller namnet på en händelsekälla och den ordnade uppsättningen egenskaper för händelsen. Olika händelser kan ha olika scheman eller dela samma schema.

Skalära uttryck

Skalära uttryck producerar skalära värden. Scalar-uttryck är indelade i följande typer:

• Konstanta uttryck
• Egenskapsreferensuttryck
• Jämförelseuttryck
• Aritmetiska uttryck
• Predikatstränguttryck

Konstanta uttryck

Du representerar konstanta uttryck med hjälp av följande literaler för var och en av de primitiva typerna:

Primitiv typ	JSON-representation	JSON-exempel	Kommentarer
Bool	Som en JSON Boolesk typ	true, false
DateTime	Som ett kapslat objekt med egenskapen single dateTime i ISO 8601-formatyyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK.	{"dateTime":"2016-08-01T00:00:00.000Z"}
Dubbel	Ett JSON-nummer som gjuts till intervallet Double.	1.23e45, 123	Dubbla spill genererar ett fel.
Sträng	En JSON-strängtyp	"abc"
Gått	Som ett kapslat objekt med egenskapen single timeSpan i ISO 8601-format : P[n]Y[n]M[n]DT[n]H[n]M[n]S.	{"timeSpan":"P1Y2M3DT4M5.67S"}

Primitiva typer som kan användas som null

Primitiva datatyper kan inte användas. null värdena för primitiva typer uttrycks i JSON på följande sätt:

{ "string": null }

{ "double": null }

{ "bool": null }

{ "dateTime": null }

{ "timeSpan": null }

Egenskapsreferensuttryck

Du använder ett egenskapsreferensuttryck för att komma åt värdena för icke-inbyggda egenskaper för en händelse. Icke-inbyggda egenskaper innehåller alla anpassade egenskaper utöver standardegenskaperna som automatiskt ingår i ett händelseschema.

Resultattypen för ett egenskapsreferensuttryck är den primitiva typen av egenskapen. Egenskaper i händelseschemat identifieras unikt efter namn och typ, och referensuttrycket kräver att båda anges.

• JSON-exempel:

  {
     "property": "p1",
     "type": "Bool"
  }
  

  {
     "property": "p1",
     "type": "DateTime"
  }
  

  {
     "property": "p1",
     "type": "Double"
  }
  

  {
     "property": "p1",
     "type": "String"
  }
  

  {
     "property": "p1",
     "type": "TimeSpan"
  }
  

Ett inbyggt egenskapsreferensuttryck används för att komma åt inbyggda egenskaper för en händelse. Inbyggda egenskaper är bara de egenskaper som definieras automatiskt i ett händelseschema.

Resultattypen för ett inbyggt egenskapsreferensuttryck är egenskapens primitiva typ. Inbyggda egenskaper refereras endast efter namn. Därför behövs ingen typ i referensuttrycket:

{ "builtInProperty": "$esn" }

Jämförelseuttryck

Följande booleska jämförelseuttryck stöds:

Egenskapsnamn i JSON	Description
eq	Lika med
I	I (lika med alla)
Fras	Innehåller fras
startsWith	Börjar med
endsWith	Slutar med fras
Regex	Matchar reguljärt uttryck
lt	Mindre än
Lte	Mindre än eller lika med
gt	Större än
Gte	Större än eller lika med

Viktigt

• Alla jämförelseuttryck tar de primitiva typerna av både vänster- och högerargument och returnerar ett booleskt värde som representerar resultatet av jämförelsen.
• Båda typerna av argumenten till vänster och höger i jämförelser bör matcha.
• Alla typer gjuts implicit endast till sig själva, och explicita casts stöds inte.

{
  "eq": {
    "left": {
      "property": "p1",
      "type": "String"
     },
     "right": "abc"
  }
}

• JSON-exempel:

  {
     "startsWith": {
       "left": {
         "property": "p1",
         "type": "String"
        },
        "right": "abc"
     }
  }
  

  {
     "startsWith": {
       "left": {
         "property": "p1",
         "type": "String"
       },
       "right": "",
       "stringComparison": "Ordinal"
     }
  }
  

  {
     "endsWith": {
       "left": {
         "property": "p1",
         "type": "String"
       },
       "right": {
         "property": "p2",
         "type": "String"
       },
       "stringComparison": "Ordinal"
     }
  }
  

Följande tabell visar typer av argument som stöds för vart och ett av jämförelseuttrycken:

Argumenttyp	Jämförelseåtgärd som stöds
Bool	eq, in
DateTime	eq, in, lt, lte, gt, gte
Dubbel	eq, in, lt, lte, gt, gte
Sträng	eq, in, phrase, startsWith, endsWith, regex
Gått	eq, in, lt, lte, gt, gte

Null-literalen kan endast användas med följande jämförelseoperatorer: eq eller in.

• Eq-operatorn resulterar i true om båda sidor är null värden. Annars resulterar operatorn i false.
• För andra åtgärder utlöses felet för NULL-literalen och beteendet är odefinierat för null-värdeegenskaper (alla jämförelseåtgärder som resulterar i ).false
• Ett null värde föregår icke-null-värden i sorteringsordningar (till exempel om sortering efter en egenskap tillämpas för att returnera en lista med händelser).

Azure Time Series Insights Gen1 stöder följande booleska logiska uttryck:

Egenskapsnamn i JSON	Description
and	Tar en icke-tom uppsättning booleska argument och returnerar true om alla utvärderas till true.
Eller	Tar en icke-tom uppsättning booleska argument och returnerar true om någon av dem utvärderas till true.
Inte	Tar ett enda booleskt argument och returnerar dess negerade värde.

{
  "and": [
    {
      "eq": {
        "left": {
          "property": "p1",
          "type": "String"
        },
        "right": "abc"
      }
    },
    {
      "not": {
        "lt": {
          "left": {
            "property": "p1",
            "type": "Double"
          },
          "right": 1
        }
      }
    }
  ]
}

Egenskapen stringComparison är valfri. Som standard är OrdinalIgnoreCasedess värde , vilket gör att meningshöljet ignoreras i jämförelser.

{
  "regex": {
    "left": {
      "property": "p1",
      "type": "String"
    },
    "right": "^abc*"
  }
}

{
  "regex": {
      "left": "abc",
      "right": "^a*$"
  }
}

Aritmetiska uttryck

Azure Time Series Insights Gen1 stöder följande aritmetiska uttryck:

Egenskapsnamn i JSON	Description
Add	Addition
Sub	Subtraktion
Mult	Multiplikation
div	Division

Alla aritmetiska uttryck tar vänster- och högerargument av primitiva typer och returnerar ett värde som representerar resultatet av åtgärden.

Alla typer gjuts implicit endast till sig själva, och explicita casts stöds inte.

{
  "add": {
    "left": {
      "property": "p1",
      "type": "Double"
     },
     "right": 1
  }
}

I följande tabell visas typer av argument som stöds för vart och ett av de aritmetiska uttrycken:

Åtgärd	Vänster typ	Rätt typ	Resultattyp
Add	Dubbel	Dubbel	Dubbel
Add	Gått	Gått	Gått
Add	DateTime	Gått	DateTime
Add	Gått	DateTime	DateTime
Sub	Dubbel	Dubbel	Dubbel
Sub	Gått	Gått	Gått
Sub	DateTime	DateTime	Gått
Sub	DateTime	Gått	DateTime
mul	Dubbel	Dubbel	Dubbel
div	Dubbel	Dubbel	Dubbel

Predikatsträngsuttryck

Booleska predikatsträngsuttryck innehåller booleska predikat som representeras som uttryck som kan läsas av människor som kallas predikatsträngar.

Exempel på predikatsträngar:

Predikatsträng	Description
Description HAS 'hello world'	true för händelser som innehåller frasen hello world i egenskapen Beskrivning för alla händelsekällor
'hello world'	true för händelser som innehåller frasen hello world
startsWith(Status, 'go')	true för händelser med status som börjar med go
endsWith(Status, 'oD')	true för händelser med status som slutar med od
startsWith_cs(Status, 'Go')	true för händelser med status som börjar med Go
endsWith_cs(Status, 'od')	true för händelser med status som börjar med od
matchesRegex(s, '^G*')	true för händelser med status som matchar det reguljära uttrycket ^G*
PointValue.Double = 3.14	true för händelser med dubbla PointValue lika med 3.14
Status IN ('Good','Bad')	true för händelser med status som innehåller Good eller Bad
PointValue > 3.14 AND Status.String = 'Good'	true för händelser med PointValue större än 3.14 och strängstatus för Good
[PointValue] > 3.14 AND ([Status] = 'Good' OR [Status] = 'Bad') AND NOT [Description] HAS 'hello world'	true för händelser med PointValue större än 3.14 och StatusGood för eller Bad och Beskrivning som inte innehåller frasen hello world

{ "predicateString": "PointValue.Double = 3.14" }

Uttrycket i predikatsträngen utvärderas till ett JSON Booleskt uttryck. Den bör följa följande (förenklad) grammatik:

Booleskt JSON-uttryck	Backus–Naur-formulär
parse	orPredicate EOF | EOF;
orPredicate	andPredicate (Or andPredicate)*;
andPredicate	notPredicate (And notPredicate)*;
notPredicate	(Not)* predicate;
predicate	parenPredicate | comparisonPredicateExtended | hasPredicate | inPredicate;
parenPredicate	OpenParen orPredicate CloseParen;
parenExpression	OpenParen additiveExpression CloseParen;
comparisonPredicateExtended	(ComparisonOp literal) | comparisonPredicate;
comparisonPredicate	additiveExpression ComparisonOp additiveExpression;
additiveExpression	multiplicativeExpression ((Plus | Minus) multiplicativeExpression)*;
multiplicativeExpression	unaryExpression (MultiplicativeOp unaryExpression)*;
functionCallExpression	identifier OpenParen CloseParen;
unaryExpression	identifier | literal | functionCallExpression | parenPredicate | parenExpression;
hasPredicate	(identifier? Has)? StringLiteral;
inPredicate	identifier? In OpenParen literal (Comma literal)* CloseParen;
literal	StringLiteral | ((Minus)? NumericLiteral) | BooleanLiteral | DateTimeLiteral | TimeSpanLiteral | NullLiteral;
identifier	BuiltinIdentifier | (QuotedOrUnquotedIdentifier (Sep QuotedOrUnquotedIdentifier)?);

Azure Time Series Insights primitiva Gen1-datatyper stöds i predikatsträngsuttryck.

Till skillnad från JSON-egenskapsreferensuttryck kan en typ för en egenskap utelämnas, vilket innebär att en typ automatiskt härleds.

Literaler som stöds

Primitiv typ	Literaler
Bool	TRUE, FALSE
DateTime	dt'2016-10-08T03:22:55.3031599Z'
Dubbel	1.23, 1.0
Sträng	'abc'
Gått	ts'P1Y2M3DT4M5.67S'
	NULL

Operandtyper som stöds

Åtgärd	Typer som stöds	Kommentarer
<, >, <=, >=	Double, DateTime, TimeSpan
=, !=, <>	String, Bool, Double, DateTime, TimeSpan, NULL	<> är ekvivalent för !=
+, -, *, /	Double, DateTime, TimeSpan
I	String, Bool, Double, DateTime, TimeSpan, NULL	Alla operander ska vara av samma typ eller vara NULL-konstant . Flera NULL-värdemotsvarar en enda NULL.
HSA	Sträng	Endast konstanta strängliteraler tillåts till höger. Tom sträng och NULL tillåts inte.

För jämförelsepredikat (<, >, <=, >=, =, !=) och IN-predikatoperand kan vara NULL eller ha en enda typ.

För uttryck med has-predikat kan den konstanta literalen till höger om HAS-operanden utökas till flera typer. Dessutom parsas konstantliteralen till höger om HAS-operanden till ett Bool-, Double-, DateTime- eller TimeSpan-värde. För varje parsat värde skapas ett predikat med operatorn = . Dessa predikat och det ursprungliga HAS-predikatet är kopplade till ett OR-predikat. Till exempel motsvarar p1.String HAS '1.0' OR p1.Double = 1.0en predikatsträng p1 HAS '1.0' , om det finns p1-egenskaper med typerna String och Double.

Typkontroll

Predikatuttryck är typkontrollerade och verifierade för att säkerställa att de högra och vänstra typerna i dem matchar.

Viktigt

• När konstanterna till vänster och höger om en operand inte matchar utlöses ett fel.
• Ett fel utlöses också om en åtgärd inte tillåts på eller mellan specifika typer.

• Om en typ anges för egenskapen tillämpas en typkontroll:

  • Alla egenskapstyper accepteras mot en NULL-literal .

  • Annars bör vänster sida och höger sida typer matcha.

    Exempel på egenskaperna p1 och p2 av strängtypen och egenskapen p3 av typen Double visas i följande tabell:

    Predikatsträng	Är giltig?	Kommentarer
    p1.String = 'abc'	Ja
    p1.String = p2.String	Ja
    p1.String = NULL	Yes	NULL matchar valfri typ av vänster sida.
    p3.Double = 'abc'	No	Typmatchningsfel.
    p3.Double = p1.String	No	Typmatchningsfel.
    p1.String HAS 'abc'	Ja
    p3.Double HAS '1.0'	Yes	Strängliteralen parsades till ett Double-värde .

• Om en typ utelämnas för egenskapen men ett namn anges utförs följande steg:

  1. Alla egenskaper med ett angivet namn och typer tas.
  2. Operander på vänster sida och höger sida grupperas i par efter typ.
  3. Par sammanfogas med hjälp av AND-åtgärder .

  • Exempel på egenskaperna p1 och p2 av typerna String och Double och några av deras motsvarigheter visas i följande tabell:

    Predikatsträng	Motsvarande sträng med starkt skrivet predikat	Kommentarer
    p1 = 'abc'	p1.String = 'abc'
    p1 = true		Ingen p1-egenskap av typen Bool, så ett egenskapsfel saknas genereras.
    p1 = NULL	p1.String = NULL AND p1.Double = NULL	För NULL höger sida förutsätts att alla matchande egenskaper ska vara NULL.
    p1 != NULL	p1.String != NULL OR p1.Double != NULL	Det här är en inversion av föregående uttryck.
    p1 = '1.0'	p1.String = '1.0'
    p1 IN (1.0, NULL)	p1.Double = 1.0 OR p1.Double = NULL
    p1 IN (NULL)	p1.String = NULL AND p1.Double = NULL	Detta motsvarar p1 = NULL.
    p1 HAS '1.0'	p1.String HAS '1.0' OR p1.Double = 1.0	Strängliteralen parsades till ett giltigt Double-värde .
    p1 HAS 'true'	p1.String HAS 'true'	Strängliteralen parsades till Bool, men ingen p1. Bool-egenskapen finns.
    p1 = p2	p1.String = p2.String AND p1.Double = p2.Double
    p1 != p2	p1.String != p2.String OR p1.Double != p2.Double	Det här är en inversion av föregående uttryck.

• Både egenskapsnamnet och typen kan utelämnas för en egenskap på vänster sida om egenskapstypen till höger är väldefinierad. Detta gäller när den högra sidan har konstanta literaler och den inte bara innehåller en NULL literal.

  • Det här scenariot är en generalisering av fulltextsökning som använder HAS-operanden.

  • Alla egenskaper som matchar typen på höger sida tas och de resulterande uttrycken sammanfogas via en OR-åtgärd .

  • Exempel på egenskapen p1 av typerna String och Double och egenskapen p2 för typerna String och DateTime visas i följande tabell:

    Predikatsträng	Motsvarande sträng med starkt skrivet predikat	Kommentarer
    = 'abc'	p1.String = 'abc' OR p2.String = 'abc'
    != 'abc'	p1.String != 'abc' AND p2.String != 'abc'	Inversion av föregående uttryck
    = 1.0	p1.Double = 1.0
    = dt'2000-01-02T03:04:05'	p2.DateTime = dt'2000-01-02T03:04:05'
    = true		Fel. Det finns ingen Bool-egenskap , så ett egenskapsfel saknas genereras.
    = NULL		Fel. Det är inte tillåtet att utelämna egenskapsnamnet för NULL höger sida.
    IN (NULL)		Samma som föregående fel.
    IN (1.0, NULL)	p1.Double = 1.0 OR p1.Double = NULL
    HAS '1.0'	p1.String HAS '1.0' OR p1.Double = 1.0 OR p2.String HAS '1.0'
    HAS 'true'	p1.String HAS 'true' OR p2.String HAS 'true'	Det finns ingen egenskap med typen Bool.

• Om operatorn utelämnas tillsammans med ett egenskapsnamn antas åtgärden HAS .

Skalärfunktioner

Skalärfunktioner returnerar skalära värden.

Inbyggda funktioner

Skalära funktioner som stöds direkt av Azure Time Series Insights Gen1 är:

Funktionsnamn	Returvärde	Argument	Exempel	Anteckningar
utcNow	DateTime	Ingen	utcNow()	Returnerar den aktuella tiden i UTC-format. Funktionsnamnet är skiftlägeskänsligt.

Funktionen UTC returnerar nu ett DateTime-värde som innehåller den aktuella tiden i UTC-format. Den accepterar inga argument.

Mängduttryck

Mängduttryck används för att partitionera samlingar av händelser och beräkningsmått över partitionerna. Mängduttryck är indelade i följande typer:

• Dimensionsuttryck
• Uttryck för unika värden
• Datum histogramuttryck
• Måttuttryck

Dimensionsuttryck

Du använder dimensionsuttryck i en aggregeringssats för att partitionera en uppsättning händelser och tilldela en skalär nyckel till varje partition.

Dimensionsuttryckstyper:

Egenskapsnamn i JSON	Beskrivning	Exempel
uniqueValues	Dimensionsvärden i resultatet är exakta värden för en viss egenskap.
dateHistogram	Dimensionsvärden i resultatet är tidsintervall för en viss egenskap.	Datumhistogrammet för tidsstämpeln kan resultera i 10 1-timmarsintervall för en 10-timmars sökomfång.
numerisktHistogram	Dimensionsvärden i resultatet är intervall med värden i en viss egenskap.	Det numeriska histogrammet med temperatur kan resultera i en avkastning på 10 grader.

Azure Time Series Insights Gen1 begränsar maximal kardinalitet, eller maximal lattice-storlek, för en mängdfråga för indata till 150 000 celler. Om du vill beräkna kardinaliteten för en mängdfråga multiplicerar du storleken på alla dimensioner i frågan. Så länge produkten är mindre än 150 000 accepteras frågan för körning. Om produkten är lika med eller mindre än 150 000 avvisas frågan.

Du anger den maximala storleken för en dimension som produceras av uniqueValues och numericHistogram med hjälp av take-satsen . I dateHistogram beräknas storleken genom att sökintervallet divideras med storleken på dateHistogramintervallet , som du anger med hjälp av satsen breaks .

En mängdfråga har till exempel sökintervallet inställt från "2017-11-15T16:00:00.000Z" till "2017-11-15T19:00:00.000Z" = 3 timmar. Om frågan innehåller dateHistogram med break-satsen , inställd på 1 minut (dimension 1) och uniqueValues över egenskapen XYZ, är dimensionsstorleken för dateHistogram 3x60=180. Det här resultatet innebär att uniqueValues kan ta upp till 150 000/180 = 833 objekt totalt.

Uttryck för unika värden

Du använder ett uttryck för unika värden för att gruppera en uppsättning händelser efter värdena för en angiven händelseegenskap.

Utvärderingen av det här JSON-uttrycket resulterar i upp till 100 poster, som grupperas efter sensorId egenskapen String.

{
  "uniqueValues": {
    "input": {
      "property": "sensorId",
      "type": "String"
    },
    "take": 100
  }
}

Datum histogramuttryck

Du använder ett datumhistogramuttryck för att gruppera DateTime-egenskapsvärden i bucketar med en angiven storlek.

En utvärdering av det här JSON-uttrycket resulterar i en uppsättning tidsstämpelposter som är golvavrundade så att varje värde har sekunder nollade.

{
  "dateHistogram": {
    "input": {
      "builtInProperty": "$ts"
    },
    "breaks": {
      "size": "1m"
    }
  }
}

Numeriska histogramuttryck

Du använder ett numeriskt histogramuttryck för att gruppera dubbla egenskapsvärden i ett angivet antal bucketar.

En utvärdering av det här JSON-uttrycket resulterar i 10 poster, så intervallet mellan de lägsta och högsta värdena för egenskapen p1 är indelat i 10 buckets.

{
  "numericHistogram": {
    "input": {
      "property": "p1",
      "type": "Double"
    },
    "breaks": {
      "count": 10
    }
  }
}

Måttuttryck

Du använder måttuttryck inuti aggregeringssatser för att beräkna ett skalärt värde för en uppsättning händelser. Ett måttuttryck är till exempel beräkningen av det högsta värdet som mäts av en temperatursensor under de senaste 24 timmarna.

Du använder ett antalsuttryck för att beräkna antalet händelser i en motsvarande bucket.

{ "count": {} }

Du använder uttrycken min, max, avg och sum för att beräkna minsta, högsta, genomsnittliga och summan av värdena för en angiven egenskap i en motsvarande bucket.

{
  "min": {
    "input": {
      "property": "temperature",
      "type": "Double"
    }
  }
}

Med första och sista måttuttryck kan du hämta värdet för en angiven egenskap A som motsvarar det lägsta eller högsta värdet för egenskapen B.

{
  "first": {
    "input": {
      "property": "propertyA",
      "type": "String"
    },
    "orderBy": {
      "property": "propertyB",
      "type": "Double"
    }
  }
}

{
  "last": {
    "input": {
      "property": "propertyA",
      "type": "Double"
    },
    "orderBy": {
      "property": "propertyB",
      "type": "DateTime"
    }
  }
}

OrderBy-satsen är valfri och har som standard egenskapen Tidsstämpel$ts. Indata kan vara av valfri typ. OrderBy-satsen stöder endast typerna Double och DateTime.

Om egenskapen B är en DateTime-typ får du det senaste eller tidigaste värdet för egenskap A.

Du kan använda första och sista uttryck för att förstå det tidigaste eller senaste värdet för en specifik egenskap. Om du till exempel har en egenskap som heter deviceID och du vill förstå det senaste deviceID som skickade en händelse är last den mest effektiva uttrycksoperatorn att använda för att identifiera den informationen.

{
  "last": {
    "input": {
      "property": "deviceID",
      "type": "String"
    }
  }
}

Ett annat exempel är att använda sist för att hitta den senast rapporterade platsen för ett visst objekt, till exempel ett fartyg, fordon eller annat rörligt objekt.

Om du vill illustrera en fråga som genererar den senast kända platsen för fartygen i en flotta kan du skapa en fråga som liknar följande:

{
  "searchSpan": {
    "from": "2018-05-05T12:00:00.000Z",
    "to": "2018-05-15T12:01:00.000Z"
  },
  "aggregates": [
     {
       "dimension": {
         "uniqueValues": {
           "input": {
             "property": "shipId",
             "type": "string"
            },
            "take": 150000
          }
        },
        "measures": [
          {
            "last": {
              "input": {
                "property": "Latitude",
                "type": "Double"
              }
           }
        },
        {
          "last": {
            "input": {
              "property": "Longitude",
              "type": "Double"
            }
          }
        }
      ]
    }
  ]
}

Ett annat exempel är att först hitta en enhet som rapporterar det lägsta trycket för varje anläggning:

{
  "searchSpan": {
    "from": "2018-05-05T12:00:00.000Z",
    "to": "2018-05-15T12:01:00.000Z"
  },
  "aggregates": [
    {
      "dimension": {
        "uniqueValues": {
          "input": {
            "property": "plantId",
            "type": "String"
          },
          "take": 150000
        }
     },
     "measures": [
       {
         "first": {
           "input": {
             "property": "deviceId",
             "type": "String"
           },
           "orderBy": {
             "property": "pressure",
              "type": "Double"
            }
          }
        }
      ]
    }
  ]
}

Stöd för dimensions- och måtttyper

Här är de dimensions- och måttuttryck som stöds, baserat på egenskapstyp:

Egenskapstyp	Dimensionsuttryck som stöds	Måttuttryck som stöds
Bool	"uniqueValues"	"first" (indata), "last" (indata)
DateTime	"uniqueValues", "dateHistogram"	"min", "max"( "first" orderBy, input), "last” (orderBy, input)
Dubbel	"uniqueValues", "numericHistogram"	"sum", "avg", "min", "max""first" (orderBy, input), "last” (orderBy, input)
Sträng	"uniqueValues"	"first" (indata), "last" (indata)

Satser

Satser utgör komponenter i JSON-frågor eller en del av ett uttryck. Satserna är indelade i följande typer:

• Sökspannsatser
• Predikatsatser
• Begränsa de översta satserna
• Begränsa take-satser
• Begränsa exempelsatser
• Brytningssatser
• Aggregat-satser

Sökspannsatser

Du använder en sökspannsats för att filtrera en inbyggd tidsstämpelegenskap för en händelse till ett visst intervall. Början av intervallet är inkluderande. Slutet av intervallet är exklusivt.

{
  "searchSpan": {
    "from": {
      "dateTime": "2016-08-01T00:00:00.000Z"
    },
    "to": {
      "dateTime": "2016-08-31T00:00:00.000Z"
    }
  }
}

Egenskaperna från och till i sökintervallsatsen (searchSpan) ska vara giltiga uttryck av resultattypen DateTime . Dessa uttryck utvärderas före frågekörningen, vilket innebär att de inte ska innehålla några egenskapsreferenser.

Predikatsatser

Du använder en predikatsats för att filtrera händelser som uppfyller predikatet. Det bör matchas till ett booleskt uttryck.

{
  "predicate": {
    "eq": {
      "left": {
        "property": "p1",
        "type": "String"
       },
       "right": "abc"
     }
  }
}

Att filtrera händelser innebär att köra ett predikat som representeras av ett booleskt uttryck för varje händelse i miljön. Körningen av ett uttryck på en händelse returneras true om händelsen måste inkluderas i ytterligare åtgärder. Den returnerar false om händelsen måste utelämnas från ytterligare bearbetning.

Anteckning

Händelser filtreras alltid efter sökintervall utöver all filtrering som anges i ett predikatuttryck.

Begränsa de översta satserna

Du använder en *limit top-sats för att hämta ett angivet antal värden i antingen stigande eller fallande ordning. Antalet värden är begränsat enligt det angivna antalet.

{
  "sort": [
    {
      "input": {
        "builtInProperty": "$ts"
      },
      "order": "Asc"
    }
  ],
  "count": 10
}

Begränsa take-satser

Du kan använda en limit take-sats som ett snabbt sätt att hämta en uppsättning värden i ingen särskild ordning. Antalet returnerade värden begränsas av angivna indata.

{ "take": 10 }

Begränsa exempelsatser

Du använder en *limit-exempelsats för att hämta ett statistiskt representativt exempel från en uppsättning värden. Antalet returnerade värden begränsas av angivna indata.

{ "sample": 10 }

Brytningssatser

Du använder en *break-sats i histogramuttryck för att ange hur ett intervall ska delas.

För datum histogram bör du ange storleken på datumintervallet och intervallgränserna. Det gör du om inte histogrammet baseras på en inbyggd tidsstämpelegenskap där gränserna bestäms baserat på sökintervall:

• Intervallgränser är valfria och kan användas. Du kan till exempel använda dem när de bestäms baserat på ett sökintervall om intervallgränser utelämnas.
• För numeriska histogram bör du ange antalet pauser. Du fastställer intervallgränser baserat på lägsta och högsta värden för en egenskap.

{
  "breaks": {
    "size": "1d",
    "from": "2000-01-02T03:04:05.0000000",
    "to": "2000-01-02T03:04:05.0000000"
  }
}

{
  "breaks": {
    "count": 10
  }
}

Aggregat-satser

Du använder en aggregeringssats för att partitionera en uppsättning händelser med en viss egenskap medan du mäter värdena för andra händelseegenskaper.

Mått utvärderas på varje partition som skapas av dimensionsuttrycket.

• I följande JSON-exempel beräknas genomsnittliga, lägsta och högsta temperaturer per sensor-ID.

  {
    "aggregates": [
      {
        "dimension": {
          "uniqueValues": {
            "input": {
              "property": "sensorId",
              "type": "String"
            },
            "take": 100
          }
        },
        "measures": [
          {
            "avg": {
              "input": {
                "property": "temperature",
                "type": "Double"
              }
            }
          },
          {
            "min": {
              "input": {
                "property": "temperature",
                "type": "Double"
              }
            }
          },
          {
            "max": {
              "input": {
                "property": "temperature",
                "type": "Double"
              }
            }
          }
        ]
      }
    ]
  }
  

  Anteckning

  En aggregeringssats är en matris där du kan ange mer än en aggregering på den översta nivån.

• I följande JSON-exempel beräknas den genomsnittliga temperaturen per stad och per tillverkare oberoende av varandra:

  {
    "aggregates": [
      {
        "dimension": {
          "uniqueValues": {
            "input": {
              "property": "city",
              "type": "String"
            },
            "take": 100
          }
        },
        "measures": [
          {
            "avg": {
              "input": {
                "property": "temperature",
                "type": "Double"
              }
            }
          }
        ]
      },
      {
        "dimension": {
          "uniqueValues": {
            "input": {
              "property": "manufacturer",
              "type": "String"
            },
            "take": 100
          }
        },
        "measures": [
          {
            "avg": {
              "input": {
                "property": "temperature",
                "type": "Double"
              }
            }
          }
        ]
      }
    ]
  }
  

  Anteckning

  • Mer än ett element i en aggregeringsmatris stöds inte för närvarande.
  • En aggregeringsdefinition kan dock innehålla en kapslad matris som anger ett mer flexibelt, flerdimensionellt gitter.

• I följande JSON-exempel beräknas medeltemperaturen per sensor-ID per minut.

  {
    "aggregates": [
      {
        "dimension": {
          "uniqueValues": {
            "input": {
              "property": "sensorId",
              "type": "String"
            },
            "take": 100
          }
        },
        "aggregate": {
          "dimension": {
            "dateHistogram": {
              "input": {
                "builtInProperty": "$ts"
              },
              "breaks": {
                "size": "1m"
              }
            }
          },
          "measures": [
            {
              "avg": {
                "input": {
                  "property": "temperature",
                  "type": "Double"
                }
              }
            }
          ]
        }
      }
    ]
  }
  

Se även

• Mer information om Azure Time Series Insights Gen1-API:er finns i Gen1-API:er.

• Mer information om parametrar för begäran och autentisering finns i Autentisering och auktorisering.

• Läs mer om Azure Time Series Insights Gen1 genom att läsa Gen1-dokumentationen.