Azure Time Series Insights Gen1 lekérdezési szintaxisa

Figyelemfelhívás

Ez egy Gen1-cikk.

Ez a cikk a Azure Time Series Insights Gen1 Query API lekérdezéskérési formátumát és szintaxisát ismerteti.

Összefoglalás

Fontos

• A lekérdezési kérelmeknek JSON formátumban kell lenniük.
• A Query API-nak küldött HTTP-kérések hasznos adatainak meg kell felelniük az ebben a cikkben megadott formátumnak.

A nyelv a következő elemekre van felosztva:

• Skaláris kifejezések, amelyek skaláris értékeket hoznak létre. A skaláris kifejezések közé tartoznak a predikátumi sztringkifejezések, az összehasonlító kifejezések és az aritmetikai kifejezések.
• Skaláris függvények, amelyek skaláris értékeket ad vissza.
• Összesítő kifejezések, amelyek az események és a számítási mértékek partícióinak particionálására szolgálnak a partíciókon.
• A JSON-lekérdezések alkotó összetevőit vagy egy kifejezés részét képező záradékok.

Adatmodell

A Azure Time Series Insights Gen1 Query API a környezeten belül egyedi eseményként tárolt adatokon működik. Minden esemény tulajdonságnév - és értékpárok halmaza.

Esemény tulajdonságai

Az eseménytulajdonságok a következő primitív típusok egyikének lehetnek: Bool, DateTime, Double vagy String. Minden primitív típus null értékű.

Megjegyzés

A testreszabott eseményforrás-formátumok nagyobb értéktípusokat támogathatnak. Azure Time Series Insights Gen1 a legközelebbi primitív típusra következtet, majd testre szabott típusokat ad hozzájuk a bejövő forgalomnál.

Minden esemény a következő beépített tulajdonságokkal rendelkezik előre definiált névvel és típussal:

Tulajdonság neve	Tulajdonságtípus	Definíció
$ts	Dátum/idő	Esemény időbélyege
$esn	Sztring	Eseményforrás neve

• Esemény időbélyege

  Alapértelmezés szerint az eseményforrás egy esemény időbélyeg-értékét adja meg. Az IoT Hubról érkező eseményekhez például időbélyegként kellene leküldni az idejüket.

  Az ügyfelek módosíthatják ezt a viselkedést egy másik eseménytulajdonság konfigurálásával. Az egyéni időbélyeg-tulajdonságok az eseményközpontokban és az IoT Hubokban adhatók meg.

• Eseményforrás neve

  Az eseményforrás neve annak az eseményforrásnak a neve, amelyről Azure Time Series Insights Gen1 megkapta az eseményt. Az eseményforrásnevek egy adott eseményhez vannak társítva a bejövő forgalom időpontjában.

  Fontos

  • Az eseményforrásnevek az esemény teljes élettartama alatt változatlanok maradnak.
  • Ha egy eseményforrás neve módosul, a meglévő események a régi eseményforrás nevét hordozzák. Az új események az új eseményforrás nevét hordozzák.

Eseménytípusok

Az egyéni eseménytulajdonságok egyedileg vannak azonosítva és hivatkozva a lekérdezési kifejezésekben név és típus szerint. Egy esemény több, azonos nevű és különböző típusú tulajdonsággal is rendelkezhet. Az azonos nevű, de különböző típusú tulajdonságok a bejövő forgalom típusának felosztásából eredhetnek.

A Sztring típusú eseménytulajdonságok a következő esetekben más típusú tulajdonságként tárolhatók:

• Ha a Sztring érték érvényes Dupla érték, akkor a rendszer a Dupla és a Sztring értékként is tárolja.
• Ha egy sztringérték érvényes DateTime érték, az csak DateTime értékként lesz tárolva.

A Query API üres sztringkonstansokat ("") null konvertál a kimenetbe.

Azure Time Series Insights Gen1 korlátozottan támogatja a következő értékeket a Kettős típuson belül: Double.NaN, Double.PositiveInfinity, és Double.NegativeInfinity. Ezek az értékek a bejövő forgalom során lesznek konvertálva null , de ha a lekérdezés kiértékelése ezen értékek egyikét állítja elő, az érték kiértékelése és szerializálása válaszként sztringként történik.

Ezeket az értékeket sztringekként is átadhatja a bejövő forgalomhoz, így a lekérdezési kifejezésekben ezeket az értékeket sztringként is át kell adni.

Az eseménysémák egy esemény tulajdonságait írják le. Az eseményséma tartalmazza az eseményforrás nevét és az eseményhez tartozó tulajdonságok rendezett készletét. A különböző események különböző sémákkal rendelkezhetnek, vagy ugyanazt a sémát oszthatják meg.

Skaláris kifejezések

A skaláris kifejezések skaláris értékeket hoznak létre. A skaláris kifejezések a következő típusokra vannak osztva:

• Állandó kifejezések
• Tulajdonsághivatkozási kifejezések
• Összehasonlító kifejezések
• Aritmetikai kifejezések
• Sztringkifejezések predikátumának megadása

Állandó kifejezések

Az állandó kifejezéseket az alábbi literálok használatával jelölheti az egyes primitív típusok esetében:

Primitív típus	JSON-reprezentáció	Példa JSON-ra	Jegyzetek
Bool	JSON logikai típusként	true, false
Dátum/idő	Beágyazott objektumként, amely egyetlen dateTime tulajdonsággal rendelkezik ISO 8601 formátumban yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK.	{"dateTime":"2016-08-01T00:00:00.000Z"}
Dupla	Egy JSON-szám, amely a Dupla tartományra van öntöttve.	1.23e45, 123	A kettős túlcsordulás hibát eredményez.
Sztring	JSON-sztringtípus	"abc"
Időtartomány	Beágyazott objektumként egyetlen timeSpan tulajdonsággal ISO 8601 formátumban: P[n]Y[n]M[n]DT[n]H[n]M[n]S.	{"timeSpan":"P1Y2M3DT4M5.67S"}

Nullable primitív típusok

A primitív adattípusok null értékűek. null a primitív típusok értékei jSON-ban vannak kifejezve az alábbiak szerint:

{ "string": null }

{ "double": null }

{ "bool": null }

{ "dateTime": null }

{ "timeSpan": null }

Tulajdonsághivatkozási kifejezések

Egy tulajdonsághivatkozási kifejezéssel érheti el egy esemény nem beépített tulajdonságainak értékeit. A nem beépített tulajdonságok közé tartoznak az alapértelmezetten felüli, az eseményséma automatikusan tartalmazott testre szabott tulajdonságai.

A tulajdonsághivatkozási kifejezés eredménytípusa a tulajdonság primitív típusa. Az eseményséma tulajdonságai név és típus alapján egyedileg vannak azonosítva, és a referenciakifejezésnek mindkettőt meg kell adnia.

• JSON-példák:

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

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

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

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

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

Az esemény beépített tulajdonságainak eléréséhez beépített tulajdonsághivatkozási kifejezés használható. A beépített tulajdonságok csak azok a tulajdonságok, amelyek automatikusan definiálva vannak egy eseménysémában.

A beépített tulajdonsághivatkozási kifejezés eredménytípusa a tulajdonság primitív típusa. A beépített tulajdonságokra csak név alapján hivatkoznak; ezért nincs szükség típusra a referenciakifejezésben:

{ "builtInProperty": "$esn" }

Összehasonlító kifejezések

A következő logikai összehasonlító kifejezések támogatottak:

Tulajdonságnév a JSON-ban	Description
eq	Egyenlő
in	In (egyenlő bármely)
Kifejezés	Kifejezéseket tartalmaz
startsWith	Ezzel kezdődik
endsWith	Kifejezéssel végződik
Regex	Normál kifejezés egyezése
lt	Kisebb, mint
Lte	Kisebb vagy egyenlő mint
gt	Nagyobb, mint
Gte	Nagyobb vagy egyenlő mint

Fontos

• Az összes összehasonlító kifejezés a bal és a jobb oldali argumentumok primitív típusait veszi figyelembe, és az összehasonlítás eredményét képviselő logikai értéket ad vissza.
• Az összehasonlításban a bal és a jobb oldali argumentumok mindkét típusának meg kell egyeznie.
• Minden típusok implicit módon csak magukra vannak vetve, és az explicit leadások nem támogatottak.

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

• JSON-példák:

  {
     "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"
     }
  }
  

Az alábbi táblázat az egyes összehasonlító kifejezések támogatott argumentumtípusait mutatja be:

Argumentum típusa	Támogatott összehasonlítási művelet
Bool	eq, in
Dátum/idő	eq, in, lt, lte, gt, gte
Dupla	eq, in, lt, lte, gt, gte
Sztring	eq, in, phrase, startsWith, endsWith, regex
Időtartomány	eq, in, lt, lte, gt, gte

A NULL literál csak a következő összehasonlító operátorokkal használható: eq vagy in.

• Az eq operátor eredménye true , ha mindkét oldal null érték. Ellenkező esetben az operátor a következőt eredményezi: false.
• Más műveletek esetén a hiba a NULL-literálnál jelentkezik, és a viselkedés nincs meghatározva a null értékű tulajdonságok esetében (bármely összehasonlító művelet, amely a következőt falseeredményezi: ).
• A null rendezési sorrendben egy érték megelőzi a nem null értékű értékeket (például ha egy tulajdonság szerinti rendezést alkalmaz az események listájának visszaadására).

Azure Time Series Insights Gen1 a következő logikai kifejezéseket támogatja:

Tulajdonságnév a JSON-ban	Description
and	Logikai argumentumok nem üres készletét veszi fel, és visszaadja true , ha mindegyik kiértékeli a értéket true.
Vagy	Logikai argumentumok nem üres készletét veszi fel, és visszaadjatrue, ha bármelyikük kiértékeli a értéket.true
Nem	Egyetlen logikai argumentumot vesz fel, és visszaadja a negated értékét.

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

A stringComparison tulajdonság nem kötelező. Alapértelmezés szerint az OrdinalIgnoreCaseértéke , ami miatt a mondatok burkolata figyelmen kívül lesz hagyva az összehasonlításokban.

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

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

Aritmetikai kifejezések

Azure Time Series Insights Gen1 a következő aritmetikai kifejezéseket támogatja:

Tulajdonságnév a JSON-ban	Description
Hozzáadása	Összeadás
Al	Kivonás
Mult	Szorzás
div	Részleg

Minden aritmetikai kifejezés a primitív típusok bal és jobb argumentumait veszi figyelembe, és a művelet eredményét képviselő értéket ad vissza.

Minden típusok implicit módon csak magukra vannak vetve, és az explicit leadások nem támogatottak.

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

Az alábbi táblázat az egyes aritmetikai kifejezések támogatott argumentumtípusait mutatja be:

Művelet	Bal oldali típus	Megfelelő típus	Eredmény típusa
Hozzáadása	Dupla	Dupla	Dupla
Hozzáadása	Időtartomány	Időtartomány	Időtartomány
Hozzáadása	Dátum/idő	Időtartomány	Dátum/idő
Hozzáadása	Időtartomány	Dátum/idő	Dátum/idő
Al	Dupla	Dupla	Dupla
Al	Időtartomány	Időtartomány	Időtartomány
Al	Dátum/idő	Dátum/idő	Időtartomány
Al	Dátum/idő	Időtartomány	Dátum/idő
Mul	Dupla	Dupla	Dupla
div	Dupla	Dupla	Dupla

Sztringkifejezések predikátumának megadása

A logikai predikátum sztringkifejezései olyan logikai predikátumokat tartalmaznak, amelyek emberi olvasásra alkalmas kifejezésekként, úgynevezett predikátumi sztringekként jelennek meg.

Példák predikátumsztringekre:

Predikátumi sztring	Description
Description HAS 'hello world'	trueolyan eseményekhez, amelyek a Description (Leírás) tulajdonságban szereplő kifejezést hello world tartalmazzák az összes eseményforrásban
'hello world'	true a kifejezést tartalmazó események esetén hello world
startsWith(Status, 'go')	true a következővel kezdődő állapotú eseményekhez: go
endsWith(Status, 'oD')	true a Status ( Állapot ) végződésű eseményekhez od
startsWith_cs(Status, 'Go')	true a következővel kezdődő állapotú eseményekhez: Go
endsWith_cs(Status, 'od')	true a következővel kezdődő állapotú eseményekhez: od
matchesRegex(s, '^G*')	true a reguláris kifejezésnek megfelelő Állapottal rendelkező események esetén ^G*
PointValue.Double = 3.14	true olyan eseményekhez, amikor a PointValue értéke megegyezik a következővel: 3.14
Status IN ('Good','Bad')	trueállapotú eseményekhez, amelyek vagy GoodBad
PointValue > 3.14 AND Status.String = 'Good'	truea PointValue értéke nagyobb, mint 3.14 a sztring állapotaGood
[PointValue] > 3.14 AND ([Status] = 'Good' OR [Status] = 'Bad') AND NOT [Description] HAS 'hello world'	true olyan eseményekhez, amelyeknél a PointValue értéke nagyobb, mint 3.14 a vagy azGoodBad állapota és a leírás , amely nem tartalmazza a kifejezést hello world

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

A predikátumi sztringben lévő kifejezés JSON logikai kifejezéssé lesz kiértékelve. Meg kell felelnie a következő (egyszerűsített) nyelvtannak:

JSON logikai kifejezés	Backus–Naur űrlap
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 Gen1 primitív adattípusokat predikátumi sztringkifejezések támogatják.

A JSON-tulajdonsághivatkozási kifejezésektől eltérően egy tulajdonság típusa kihagyható, amely esetben a rendszer automatikusan kikövetkeztet egy típust.

Támogatott literálok

Primitív típus	Literálok
Bool	TRUE, FALSE
Dátum/idő	dt'2016-10-08T03:22:55.3031599Z'
Dupla	1.23, 1.0
Sztring	'abc'
Időtartomány	ts'P1Y2M3DT4M5.67S'
	NULL

Támogatott operandustípusok

Művelet	Támogatott típusok	Jegyzetek
<, >, <=, >=	Double, DateTime, TimeSpan
=, !=, <>	String, Bool, Double, DateTime, TimeSpan, NULL	<>egyenértékű a != értékkel
+, -, *, /	Double, DateTime, TimeSpan
IN	String, Bool, Double, DateTime, TimeSpan, NULL	Minden operandusnak azonos típusúnak vagy NULL állandónak kell lennie. Több NULLs egyenértékű egyetlen NULL értékkel.
HSA	Sztring	A jobb oldalon csak állandó sztringkonstansok engedélyezettek. Az üres sztring és a NULL nem engedélyezett.

Az összehasonlítási predikátumok (<, , >=<, >=, =, !=) és az IN predikátum operandusa null értékű lehet, vagy egyetlen típussal rendelkezhet.

A HAS predikátummal rendelkező kifejezések esetében a HAS operandus jobb oldalán lévő konstans literál több típusra bontható. Emellett a HAS operandus jobb oldalán lévő állandó literál egy Bool, Double, DateTime vagy TimeSpan értékké lesz elemezve. Minden sikeresen elemzett értékhez létrejön egy predikátum az = operátorral. Ezek a predikátumok és az eredeti HAS predikátum or predikátumhoz vannak csatlakoztatva. Egy predikátumsztring p1 HAS '1.0' például egyenértékű a következővel p1.String HAS '1.0' OR p1.Double = 1.0: , ha a p1 tulajdonság sztringgel és dupla típussal rendelkezik.

Típusellenőrzés

A predikátumkifejezések típusellenőrzéssel és ellenőrzéssel gondoskodnak arról, hogy a bennük lévő jobb és bal oldali típusok egyezzenek.

Fontos

• Ha az operandus bal és jobb oldalán lévő állandók nem egyeznek, a rendszer hibát jelez.
• Akkor is hibaüzenet jelenik meg, ha egy művelet nem engedélyezett adott típusokon vagy típusok között.

• Ha a tulajdonsághoz típus van megadva, a rendszer típusellenőrzést alkalmaz:

  • Bármely tulajdonságtípust elfogad egy NULL-literál .

  • Ellenkező esetben a bal és a jobb oldali típusnak egyeznie kell.

    Példák a Sztring típusú p1 és p2 tulajdonságokra, valamint a Dupla típusú p3 tulajdonságra az alábbi táblázatban láthatók:

    Predikátumi sztring	Érvényes?	Jegyzetek
    p1.String = 'abc'	Igen
    p1.String = p2.String	Igen
    p1.String = NULL	Yes	NULL bármely bal oldali típusra illeszkedik.
    p3.Double = 'abc'	No	Típuseltérés.
    p3.Double = p1.String	No	Típuseltérés.
    p1.String HAS 'abc'	Igen
    p3.Double HAS '1.0'	Yes	A sztringkonstans sikeresen át lett elemezve dupla értékre.

• Ha nincs megadva típus a tulajdonsághoz, de meg van adva egy név, a következő lépések lesznek végrehajtva:

  1. A rendszer minden megadott nevű és típusú tulajdonságot figyelembe vesz.
  2. A bal és a jobb oldali operandusok típus szerint párba vannak csoportosítva.
  3. A párok ÉS műveletekkel összefűzhetők.

  • A sztring- és kettős típusú p1 és p2 tulajdonságokra és azok megfelelőire az alábbi táblázatban láthatók példák:

    Predikátumi sztring	Egyenértékű erős típusú predikátumsztring	Jegyzetek
    p1 = 'abc'	p1.String = 'abc'
    p1 = true		Nincs a Bool típusú p1 tulajdonság, ezért hiányzó tulajdonsághiba jelenik meg.
    p1 = NULL	p1.String = NULL AND p1.Double = NULL	A NULL jobb oldalon feltételezzük, hogy az összes egyező tulajdonságnak a következőnek kell lennie NULL: .
    p1 != NULL	p1.String != NULL OR p1.Double != NULL	Ez az előző kifejezés inverziója.
    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	Ez a megfelelője.p1 = NULL
    p1 HAS '1.0'	p1.String HAS '1.0' OR p1.Double = 1.0	A sztringkonstans sikeresen át lett elemezve egy érvényes dupla értékre.
    p1 HAS 'true'	p1.String HAS 'true'	A sztringkonstans sikeresen ki lett elemezve a Bool-ban, de p1 nem. A Bool tulajdonság létezik.
    p1 = p2	p1.String = p2.String AND p1.Double = p2.Double
    p1 != p2	p1.String != p2.String OR p1.Double != p2.Double	Ez az előző kifejezés inverziója.

• A tulajdonságnév és a típus is kihagyható egy bal oldali tulajdonság esetében, ha a jobb oldali tulajdonságtípus jól van definiálva. Ez akkor igaz, ha a jobb oldalon állandó literálok vannak, és nem tartalmaz csak literált NULL .

  • Ez a forgatókönyv a HAS operandust használó teljes szöveges keresés általánosítása.

  • A rendszer a jobb oldali típusnak megfelelő összes tulajdonságot beszúrja, és az eredményül kapott kifejezéseket egy VAGY művelettel fűzi össze.

  • A Sztring és a Dupla típus p1 tulajdonságára, valamint a Sztring és a DateTime típus p2 tulajdonságára példák jelennek meg az alábbi táblázatban:

    Predikátumi sztring	Egyenértékű erős típusú predikátumsztring	Jegyzetek
    = 'abc'	p1.String = 'abc' OR p2.String = 'abc'
    != 'abc'	p1.String != 'abc' AND p2.String != 'abc'	Az előző kifejezés inverziója
    = 1.0	p1.Double = 1.0
    = dt'2000-01-02T03:04:05'	p2.DateTime = dt'2000-01-02T03:04:05'
    = true		HIba. Nincs Bool tulajdonság, ezért hiányzó tulajdonsághiba jelenik meg.
    = NULL		HIba. A jobb oldali tulajdonságnév NULL kihagyása nem engedélyezett.
    IN (NULL)		Ugyanaz, mint az előző hiba.
    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'	Nincs Bool típusú tulajdonság.

• Ha az operátort egy tulajdonságnévvel együtt nem adja meg, akkor a rendszer feltételezi a HAS műveletet.

Skaláris függvények

A skaláris függvények skaláris értékeket ad vissza.

Natív függvények

Az Azure Time Series Insights Gen1 által beépítetten támogatott skaláris függvények a következők:

Függvény neve	Visszatérési érték	Argumentumok	Példa	Megjegyzések
utcNow	Dátum/idő	None	utcNow()	Az aktuális időpontot adja vissza UTC formátumban. A függvény neve megkülönbözteti a kis- és nagybetűt.

Az UTC most függvény egy DateTime értéket ad vissza, amely utc formátumban tartalmazza az aktuális időt. Nem fogad el argumentumokat.

Összesítő kifejezések

Az összesítő kifejezések az események és a számítási mértékek partíciógyűjteményeinek particionálására szolgálnak a partíciókon. Az összesítő kifejezések a következő típusokra vannak osztva:

• Dimenziókifejezések
• Egyedi értékek kifejezései
• Dátum hisztogram-kifejezések
• Mértékkifejezések

Dimenziókifejezések

Az összesítési záradékbandimenziókifejezéseket használva particionálhatja az eseményeket, és skaláris kulcsot rendelhet az egyes partíciókhoz.

Dimenziókifejezés-típusok:

Tulajdonságnév a JSON-ban	Leírás	Példa
uniqueValues	Az eredményben szereplő dimenzióértékek egy adott tulajdonság pontos értékei.
dateHistogram	Az eredményben szereplő dimenzióértékek egy adott tulajdonság időtartományai.	Az időbélyeg dátum hisztogramja 10 1 órás tartományt eredményezhet a 10 órás keresési időtartamhoz.
numericHistogram	Az eredményben szereplő dimenzióértékek egy adott tulajdonságban lévő értékek tartományai.	A hőmérséklet numerikus hisztogramja 10 foktartomány visszatérését eredményezheti.

Azure Time Series Insights Gen1 egy bemeneti összesítő lekérdezés maximális számosságát vagy maximális rácsméretét 150 000 cellára korlátozza. Az összesítő lekérdezés számosságának kiszámításához meg kell szoroznia a lekérdezés összes dimenziójának méretét. Ha a termék kevesebb, mint 150 000, a lekérdezést a program elfogadja a végrehajtáshoz. Ha a termék legalább 150 000, a rendszer elutasítja a lekérdezést.

A take záradék használatával megadhatja a uniqueValues és a numericHistogram által előállított dimenziók maximális méretét. A dateHistogramban a rendszer úgy számítja ki a méretet, hogy elosztja a keresési tartományt a dateHistogram intervallum méretével, amelyet a breaks záradékkal ad meg.

Az összesített lekérdezések keresési tartománya például "2017-11-15T16:00:00.000Z" értékről "2017-11-15T19:00:00.000Z" = 3 óra. Ha a lekérdezés tartalmaz egy dateHistogramot a törési záradékkal, amely 1 percre (1. dimenzió) és uniqueValues értékre van állítva az XYZ tulajdonságnál, a dateHistogram dimenziómérete 3x60=180. Ez az eredmény azt jelenti, hogy az egyedi értékek akár 150 000/180 = 833 tételt is igénybe vehetnek.

Egyedi értékek kifejezései

Egyedi értékkifejezéssel csoportosíthatja egy eseménykészletet egy adott eseménytulajdonság értékei alapján.

A JSON-kifejezés kiértékelése legfeljebb 100 rekordot eredményez, amelyek a sensorIdString tulajdonság szerint vannak csoportosítva.

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

Dátum hisztogram-kifejezések

A date hisztogram kifejezéssel a DateTime tulajdonságértékeket egy megadott méretű gyűjtőkbe csoportosíthatja.

Ennek a JSON-kifejezésnek a kiértékelése olyan időbélyeg-rekordokat eredményez, amelyek úgy vannak lekerekítetten, hogy az egyes értékek másodpercben nullázva legyenek.

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

Numerikus hisztogram-kifejezések

Numerikus hisztogram-kifejezéssel csoportosíthatja a dupla tulajdonságértékeket egy megadott számú gyűjtőbe.

A JSON-kifejezés kiértékelése 10 rekordot eredményez, így a p1 tulajdonság minimális és maximális értékei közötti tartomány 10 gyűjtőre van osztva.

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

Mértékkifejezések

Az összesítési záradékokbanmértékkifejezéseket használva skaláris értékeket számíthat ki egy eseménykészleten. A mértékkifejezés például egy hőmérséklet-érzékelő által az elmúlt 24 órában mért maximális érték kiszámítása.

A count kifejezéssel kiszámíthatja a megfelelő gyűjtőben lévő események számát.

{ "count": {} }

A min, max, avg és az sum kifejezésekkel kiszámíthatja egy adott tulajdonság értékeinek minimális, maximumát, átlagát és összegét a megfelelő gyűjtőben.

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

Az első és az utolsó mértékkifejezéssel lekérheti egy megadott A tulajdonság értékét, amely megfelel a B tulajdonság minimális vagy maximális értékének.

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

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

Az orderBy záradék nem kötelező, és alapértelmezés szerint a Timestamp tulajdonság $ts. A bemenet bármilyen típusú lehet. Az orderBy záradék csak a Double és DateTime típusokat támogatja.

Ha a B tulajdonság DateTime típusú, az A tulajdonság legújabb vagy legkorábbi értékét kapja meg.

Az első és az utolsó kifejezéssel megismerheti egy adott tulajdonság legkorábbi vagy legújabb értékét. Ha például van egy nevű deviceID tulajdonsága, és meg szeretné érteni az eseményt küldő legutóbbit deviceID , az utolsó a leghatékonyabb kifejezésoperátor, amellyel azonosíthatja ezeket az információkat.

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

Egy másik példa egy adott objektum utolsó jelentett helyének megkeresésére, például hajó, jármű vagy más mozgó objektum.

Egy flotta hajóinak utolsó ismert helyét létrehozó lekérdezés szemléltetéséhez az alábbihoz hasonló lekérdezést hozhat létre:

{
  "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"
            }
          }
        }
      ]
    }
  ]
}

Egy másik példa, ha először egy olyan eszközt keres, amely minden növényre a legalacsonyabb nyomást jelenti:

{
  "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"
            }
          }
        }
      ]
    }
  ]
}

Dimenzió- és mértéktípus-támogatás

A támogatott dimenzió- és mértékkifejezések a tulajdonságtípus alapján:

Tulajdonság típusa	Támogatott dimenziókifejezések	Támogatott mértékkifejezések
Bool	"uniqueValues"	"first" (bemenet), "last" (bemenet)
Dátum/idő	"uniqueValues", "dateHistogram"	"min", "max", "first" (orderBy, input), "last” (orderBy, input)
Dupla	"uniqueValues", "numericHistogram"	"sum", "avg", "min", "max""first" (orderBy, input), "last” (orderBy, input)
Sztring	"uniqueValues"	"first" (bemenet), "last" (bemenet)

Záradékok

A záradékok A JSON-lekérdezések vagy egy kifejezés egy része alkotó összetevői. A záradékok a következő típusúak:

• Keresési span záradékok
• Predikátumi záradékok
• Felső záradékok korlátozása
• A bevételi záradékok korlátozása
• Mintamondatok korlátozása
• Törési záradékok
• Záradékok összesítése

Keresési span záradékok

Keresési span záradékkal szűrheti egy esemény beépített Timestamp tulajdonságát egy adott intervallumra. Az intervallum kezdete a befogadó. Az intervallum vége kizárólagos.

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

A keresési span záradékban (searchSpan) szereplő forrás- és tulajdonságnak a DateTime eredménytípus érvényes kifejezéseinek kell lenniük. Ezeket a kifejezéseket a lekérdezés végrehajtása előtt értékeli ki a rendszer, ami azt jelenti, hogy nem tartalmazhatnak tulajdonsághivatkozásokat.

Predikátumi záradékok

Predikátum záradékkal szűrheti azokat az eseményeket, amelyek megfelelnek a predikátumnak. Logikai kifejezésre kell feloldani.

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

Az események szűréséhez olyan predikátumot kell futtatni, amelyet logikai kifejezés jelöl a környezet minden egyes eseményén. Egy kifejezés végrehajtása egy eseményen akkor ad true vissza eredményt, ha az eseményt további műveletekbe kell belefoglalni. Visszaadja false , ha az eseményt ki kell hagyni a további feldolgozásból.

Megjegyzés

Az eseményeket a predikátumkifejezésekben megadott szűrések mellett a keresési tartomány is szűri.

Felső záradékok korlátozása

A *felső korlát záradék használatával meghatározott számú értéket kaphat növekvő vagy csökkenő sorrendben. Az értékek száma a megadott szám szerint korlátozott.

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

A bevételi záradékok korlátozása

A korlátelvételi záradékot gyors módszerként használhatja az értékek adott sorrendben történő lekéréséhez. A visszaadott értékek számát a megadott bemenet korlátozza.

{ "take": 10 }

Mintamondatok korlátozása

A *limit sample záradék használatával statisztikailag reprezentatív mintát kérhet le egy értékkészletből. A visszaadott értékek számát a megadott bemenet korlátozza.

{ "sample": 10 }

Törési záradékok

A hisztogramkifejezésekben a *törési záradék használatával adhatja meg a tartomány felosztásának módját.

Dátum hisztogramok esetében meg kell adnia a datetime intervallum és az intervallumhatárok méretét. Ezt csak akkor teheti meg, ha a hisztogram egy beépített Timestamp tulajdonságon alapul, ahol a határok a keresési tartomány alapján vannak meghatározva:

• Az intervallumhatárok nem kötelezőek, és használhatók. Például akkor használhatja őket, ha a keresési tartomány alapján vannak meghatározva, ha kihagyja az intervallumhatárokat.
• Numerikus hisztogramok esetén meg kell adnia a törések számát. Az intervallumhatárokat egy tulajdonság minimális és maximális értékei alapján határozhatja meg.

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

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

Záradékok összesítése

Az összesítési záradék használatával particionálhat egy eseménykészletet egy adott tulajdonság alapján, miközben más eseménytulajdonságok értékeit méri.

A mértékek kiértékelése minden olyan partíción történik, amelyet a dimenziókifejezés állít elő.

• Az alábbi JSON-példa az érzékelőazonosítónkénti átlagot, minimumot és maximális hőmérsékletet számítja ki.

  {
    "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"
              }
            }
          }
        ]
      }
    ]
  }
  

  Megjegyzés

  Az aggregátumok záradéka egy tömb, amely lehetővé teszi több összesítés megadását a legfelső szinten.

• Az alábbi JSON-példa a városonkénti és gyártónkénti átlaghőmérsékletet számítja ki egymástól függetlenül:

  {
    "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"
              }
            }
          }
        ]
      }
    ]
  }
  

  Megjegyzés

  • Az összesítő tömb egynél több eleme jelenleg nem támogatott.
  • Az összesítési definíció azonban tartalmazhat beágyazott tömböt, amely rugalmasabb, többdimenziós rácsot ad meg.

• Az alábbi JSON-példa az érzékelőazonosítónkénti átlagos hőmérsékletet számítja ki percenként.

  {
    "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"
                }
              }
            }
          ]
        }
      }
    ]
  }
  

Lásd még

• A Azure Time Series Insights Gen1 API-kkal kapcsolatos további információkért lásd: Gen1 API-k.

• A kérelem- és hitelesítési paraméterekkel kapcsolatos további információkért lásd: Hitelesítés és engedélyezés.

• Az 1. generációs Azure Time Series Insights a Gen1 dokumentációjának áttekintésével talál további információt.