Megosztás a következőn keresztül:

Azure Time Series Insights Gen1 lekérdezési szintaxisa

  • Cikk

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:

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

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

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

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.