AWS IoT TwinMaker grafik pengetahuan sumber daya tambahan

Bagian ini memberikan contoh dasar sintaks PartiQL yang digunakan untuk menulis kueri dalam grafik pengetahuan, serta tautan ke dokumentasi PartiQL yang memberikan informasi tentang model data grafik pengetahuan.

Kumpulan contoh ini menunjukkan kueri dasar dengan tanggapan mereka. Gunakan ini sebagai referensi untuk menulis kueri Anda sendiri.

Kueri dasar

Dapatkan semua entitas dengan filter
```
SELECT entity
FROM EntityGraph MATCH (entity)
WHERE entity.entityName = 'room_0'
```
Kueri ini mengembalikan semua entitas di ruang kerja dengan namaroom_0.

FROMklausa: EntityGraph adalah kumpulan grafik yang berisi semua entitas dan hubungannya di ruang kerja. Koleksi ini secara otomatis dibuat dan dikelola AWS IoT TwinMaker berdasarkan entitas di ruang kerja Anda.

MATCHklausa: menentukan pola yang cocok dengan sebagian grafik. Dalam hal ini, pola (entity) cocok dengan setiap node dalam grafik dan terikat pada variabel entitas. K FROM lausul harus diikuti oleh MATCH klausa.

WHEREklausa: menentukan filter pada entityName bidang node, di mana nilainya harus cocokroom_0.

SELECTklausa: menentukan entity variabel sehingga seluruh node entitas dikembalikan.

Tanggapan:
```
{
  "columnDescriptions": [
    {
      "name": "entity",
      "type": "NODE"
    }
  ],
  "rows": [
    {
      "rowData": [
        {
          "arn": "arn:aws:iottwinmaker:us-east-1: 577476956029: workspace / SmartBuilding8292022 / entity / room_18f3ef90 - 7197 - 53 d1 - abab - db9c9ad02781 ",
          "creationDate": 1661811123914,
          "entityId": "room_18f3ef90-7197-53d1-abab-db9c9ad02781",
          "entityName": "room_0",
          "lastUpdateDate": 1661811125072,
          "workspaceId": "SmartBuilding8292022",
          "description": "",
          "components": [
            {
              "componentName": "RoomComponent",
              "componentTypeId": "com.example.query.construction.room",
              "properties": [
                {
                  "propertyName": "roomFunction",
                  "propertyValue": "meeting"
                },
                {
                  "propertyName": "roomNumber",
                  "propertyValue": 0
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}
```
Meng columnDescriptions embalikan metadata tentang kolom, seperti nama dan jenis. Jenis yang dikembalikan adalahNODE. Ini menunjukkan bahwa seluruh node telah dikembalikan. Nilai lain untuk tipe dapat EDGE menunjukkan hubungan atau VALUE yang akan menunjukkan nilai skalar seperti integer atau string.

Meng rows embalikan daftar baris. Karena hanya satu entitas yang dicocok rowData kan, satu dikembalikan yang berisi semua bidang dalam entitas.

catatan
Tidak seperti SQL di mana Anda hanya dapat mengembalikan nilai skalar, Anda dapat mengembalikan objek (sebagai JSON) menggunakan PartiQL.

Setiap node berisi semua bidang tingkat entitas sepertientityId, arn dancomponents, bidang tingkat komponen seperticomponentName, componentTypeId dan properties juga bidang tingkat properti seperti dan, semuanya sebagai JSON ber propertyName sar propertyValue ang.
Dapatkan semua hubungan dengan filter:
```
SELECT relationship
FROM EntityGraph MATCH (e1)-[relationship]->(e2)
WHERE relationship.relationshipName = 'isLocationOf'
```
Kueri ini mengembalikan semua hubungan di ruang kerja dengan nama hubunganisLocationOf.

Kla MATCH usa: menentukan pola yang cocok dengan dua node (ditunjukkan oleh()) yang dihubungkan oleh tepi terarah (ditunjukkan oleh-[]->) dan terikat ke variabel yang disebutrelationship.

Kla WHERE usa: menentukan filter pada relationshipName bidang tepi, di mana nilainya beradaisLocationOf.

Kla SELECT usa: menentukan variabel hubungan sehingga seluruh node tepi dikembalikan.

Respons
```
{
    "columnDescriptions": [{
        "name": "relationship",
        "type": "EDGE"
    }],
    "rows": [{
        "rowData": [{
            "relationshipName": "isLocationOf",
            "sourceEntityId": "floor_83faea7a-ea3b-56b7-8e22-562f0cf90c5a",
            "targetEntityId": "building_4ec7f9e9-e67e-543f-9d1b- 235df7e3f6a8",
            "sourceComponentName": "FloorComponent",
            "sourceComponentTypeId": "com.example.query.construction.floor"
        }]
    },
        ... //rest of the rows are omitted
    ]
}
```
Jenis kolom di dalamnya columnDescriptions adalahEDGE.

Masing-masing rowData mewakili tepi dengan bidang sepertirelationshipName. Ini sama dengan nama properti hubungan yang didefinisikan pada entitas. ThesourceEntityId, sourceComponentName dan sourceComponentTypeId memberikan informasi tentang entitas dan komponen mana properti hubungan didefinisikan. Men targetEntityId entukan entitas mana yang mengarah ke hubungan ini.
Dapatkan semua entitas dengan hubungan tertentu ke entitas tertentu
```
SELECT e2.entityName
      FROM EntityGraph MATCH (e1)-[r]->(e2)
      WHERE relationship.relationshipName = 'isLocationOf'
      AND e1.entityName = 'room_0'
```
Kueri ini mengembalikan semua nama entitas dari semua entitas yang memiliki isLocationOf hubungan dengan room_0 entitas.

Kla MATCH usa: menentukan pola yang cocok dengan dua node (e1,e2) yang memiliki tepi terarah (r).

Kla WHERE usa: menentukan filter pada nama hubungan dan nama entitas sumber.

Kla SELECT usa: mengembalikan entityName bidang di e2 node.

Respons
```
{
  "columnDescriptions": [
    {
       "name": "entityName",
       "type": "VALUE"
    }
  ],
   "rows": [
    {
       "rowData": [
         "floor_0"
      ]
    }
  ]
}
```
Dalam ColumnDescriptions, jenis kolom tersebut VALUE entityName adalah string.

Satu entitas,floor_0, dikembalikan.

PERTANDINGAN

Pola berikut didukung dalam MATCH klausa:

Cocokkan simpul 'b' menunjuk ke simpul 'a':
```
FROM EntityGraph MATCH (a)-[rel]-(b)
```
Cocokkan simpul 'a' menunjuk ke simpul 'b':
```
FROM EntityGraph MATCH (a)-[]->(b)
```
Tidak ada variabel yang terikat pada hubungan dengan asumsi filter tidak perlu ditentukan pada hubungan.
Cocokkan simpul 'a' menunjuk ke simpul 'b' dan simpul 'b' menunjuk ke simpul 'a':
```
FROM EntityGraph MATCH (a)-[rel]-(b)
```
Ini akan mengembalikan dua pertandingan: satu dari 'a' ke 'b' dan satu lagi dari 'b' ke 'a', jadi rekomendasinya adalah menggunakan tepi terarah sedapat mungkin.
Nama hubungan juga merupakan label grafik propertiEntityGraph, jadi Anda cukup menentukan nama hubungan setelah titik dua (:) alih-alih menentukan filter rel.relationshipName pada WHERE klausa.
```
FROM EntityGraph MATCH (a)-[:isLocationOf]-(b)
```
Rantaian: pola dapat dirantai agar sesuai dengan beberapa hubungan.
```
FROM EntityGraph MATCH (a)-[rel1]->(b)-[rel2]-(c)
```
Pola hop variabel dapat menjangkau beberapa node dan tepi juga:
```
FROM EntityGraph MATCH (a)-[]->{1,5}(b)
```
Kueri ini cocok dengan pola apa pun dengan tepi keluar dari node 'a' dalam 1 hingga 5 hop. Kuantifier yang diizinkan adalah:

{m,n}- antara m dan n pengulangan

{m,}- m atau lebih pengulangan.

DARI:

Node entitas dapat berisi data bersarang, seperti komponen yang sendiri berisi data bersarang lebih lanjut seperti properti. Ini dapat diakses dengan menghapus sarang hasil pola MATCH.


SELECT e
FROM EntityGraph MATCH (e), e.components AS c, c.properties AS p
WHERE c.componentTypeId = 'com.example.query.construction.room',
AND p.propertyName = 'roomFunction'
AND p.propertyValue = 'meeting'

Akses bidang bersarang dengan menyortir . ke variabel. Sebuah koma (,) digunakan untuk menguji (atau menggabungkan) entitas dengan komponen di dalamnya dan kemudian properti di dalam komponen tersebut. ASdigunakan untuk mengikat variabel ke variabel yang tidak bersarang sehingga mereka dapat digunakan dalam klausa WHERE atauSELECT. Kueri ini mengembalikan semua entitas yang berisi properti bernama roomFunction dengan nilai meeting dalam komponen dengan id tipe komponen com.example.query.construction.room

Untuk mengakses beberapa bidang bersarang dari bidang seperti beberapa komponen dalam entitas, gunakan notasi koma untuk melakukan gabungan.


SELECT e
FROM EntityGraph MATCH (e), e.components AS c1, e.components AS c2

PILIH:

Kembalikan simpul:
```
SELECT e
FROM EntityGraph MATCH (e)
```

Kembalikan tepi:


SELECT r
FROM EntityGraph MATCH (e1)-[r]->(e2)

Kembalikan nilai skalar:
```
SELECT floor.entityName, room.description, p.propertyValue AS roomfunction
FROM EntityGraph MATCH (floor)-[:isLocationOf]-(room),
room.components AS c, c.properties AS p
```
Format nama bidang keluaran dengan mengaliasikannya menggunakanAS. Di sini, alih-alih propertyValue sebagai nama kolom dalam respons, roomfunction dikembalikan.

Kembalikan alias:


SELECT floor.entityName AS floorName, luminaire.entityName as luminaireName
FROM EntityGraph MATCH (floor)-[:isLocationOf]-(room)-[:hasPart]-
(lightingZone)-[:feed]-(luminaire)
WHERE floor.entityName = 'floor_0'
AND luminaire.entityName like 'lumin%'

Menggunakan alias sangat disarankan untuk menjadi eksplisit, meningkatkan keterbacaan, dan menghindari ambiguitas dalam kueri Anda.

DIMANA:

Operator logis yang didukung adalahAND,NOT, danOR.
Operator perbandingan yang didukung adalah <<=,>,=>,,=, dan!=.
Gunakan IN kata kunci jika Anda ingin menentukan beberapa OR kondisi pada bidang yang sama.

Filter pada bidang entitas, komponen atau properti:


FROM EntityGraph MATCH (e), e.components AS c, c.properties AS p
WHERE e.entityName = 'room_0'
AND c.componentTypeId = 'com.example.query.construction.room',
AND p.propertyName = 'roomFunction'
AND NOT p.propertyValue = 'meeting'
OR p.propertyValue = 'office'

Filter pada configuration properti. Berikut unit adalah kunci dalam peta konfigurasi dan Celsius nilainya.
```
WHERE p.definition.configuration.unit = 'Celsius'
```
Periksa apakah properti peta berisi kunci dan nilai yang diberikan:
```
WHERE p.propertyValue.length = 20.0
```
Periksa apakah properti peta berisi kunci yang diberikan:
```
WHERE NOT p.propertyValue.length IS MISSING
```
Periksa apakah properti daftar berisi nilai yang diberikan:
```
WHERE 10.0 IN p.propertyValue
```
Gunakan lower() fungsi untuk perbandingan yang tidak peka huruf besar/kecil. Secara default, semua perbandingan peka huruf besar/kecil.
```
WHERE lower(p.propertyValue) = 'meeting'
```

SUKA:

Berguna jika Anda tidak tahu nilai pasti untuk bidang dan dapat melakukan pencarian teks lengkap pada bidang yang ditentukan. %mewakili nol atau lebih.


WHERE e.entityName LIKE '%room%'

Pencarian infix: %room%
Pencarian awalan: room%
Pencarian akhiran: %room
Jika Anda memiliki '%' dalam nilai Anda, maka letakkan karakter escape di LIKE dan tentukan karakter escape denganESCAPE.


WHERE e.entityName LIKE 'room\%' ESCAPE '\'

BERBEDA:


SELECT DISTINCT c.componentTypeId
FROM EntityGraph MATCH (e), e.components AS c

DISTINCTKata kunci menghilangkan duplikat dari hasil akhir.

DISTINCTtidak didukung pada tipe data yang kompleks.

HITUNG


SELECT COUNT(e), COUNT(c.componentTypeId)
FROM EntityGraph MATCH (e), e.components AS c

COUNTKata kunci menghitung jumlah item dalam hasil kueri.
COUNTtidak didukung pada bidang kompleks bersarang dan bidang pola grafik.
COUNTagregasi tidak didukung dengan kueri DISTINCT dan bersarang.

Misalnya, COUNT(DISTINCT e.entityId) tidak didukung.

JALAN

Proyeksi pola berikut didukung dalam kueri menggunakan proyeksi jalur:

Kueri hop variabel
```
SELECT p FROM EntityGraph MATCH p = (a)-[]->{1, 3}(b)
```
Kueri ini cocok dan memproyeksikan metadata node dari pola apa pun dengan tepi keluar dari node a dalam 1 hingga 3 hop.
Kueri hop tetap
```
SELECT p FROM EntityGraph MATCH p = (a)-[]->(b)<-[]-(c)
```
Kueri ini cocok dan memproyeksikan metadata entitas dan tepi masuk ke b.

Kueri tidak diarahkan


SELECT p FROM EntityGraph MATCH p = (a)-[]-(b)-[]-(c)

Kueri ini cocok dan memproyeksikan metadata node dalam 1 pola hop yang menghubungkan a dan c melalui b.


{
    "columnDescriptions": [
        {
            "name": "path",
            "type": "PATH"
        }
    ],
    "rows": [
        {
            "rowData": [
                {
                    "path": [
                        {
                            "entityId": "a",
                            "entityName": "a"
                        },
                        {
                            "relationshipName": "a-to-b-relation",
                            "sourceEntityId": "a",
                            "targetEntityId": "b"
                        },
                        {
                            "entityId": "b",
                            "entityName": "b"
                        }
                    ]
                }
            ]
        },
        {
            "rowData": [
                {
                    "path": [
                        {
                            "entityId": "b",
                            "entityName": "b"
                        },
                        {
                            "relationshipName": "b-to-c-relation",
                            "sourceEntityId": "b",
                            "targetEntityId": "c"
                        },
                        {
                            "entityId": "c",
                            "entityName": "c"
                        }
                    ]
                }
            ]
        }
    ]
}

Resp PATH ons kueri ini hanya terdiri dari metadata yang mengidentifikasi semua node dan tepi masing-masing path/pattern antara a dan c melalui b.

LIMIT dan OFFSET:


SELECT e.entityName
FROM EntityGraph MATCH (e)
WHERE e.entityName LIKE 'room_%'
LIMIT 10
OFFSET 5

LIMITmenentukan jumlah hasil yang akan dikembalikan dalam kueri, dan OFFSET menentukan jumlah hasil yang akan dilewati.

LIMIT dan MAXResults:

Contoh berikut menunjukkan kueri yang mengembalikan 500 hasil secara total, tetapi hanya menampilkan 50 sekaligus per panggilan API. Pola ini dapat digunakan di mana Anda perlu membatasi jumlah hasil yang ditampilkan, misalnya jika Anda hanya dapat menampilkan 50 hasil dalam UI.


aws iottwinmaker execute-query \
--workspace-id exampleWorkspace \
--query-statement "SELECT e FROM EntityGraph MATCH (e) LIMIT 500"\
--max-results 50

LIMITKata kunci mempengaruhi kueri dan membatasi baris yang dihasilkan. Jika Anda perlu mengontrol jumlah hasil yang dikembalikan per panggilan API tanpa membatasi jumlah total hasil yang dikembalikan, gunakanLIMIT.
max-resultsadalah parameter opsional untuk tindakan ExecuteQuery API. max-resultshanya berlaku untuk API dan bagaimana hasil dibaca dalam batas kueri di atas.

Menggunakan max-results dalam kueri memungkinkan Anda mengurangi jumlah hasil yang ditampilkan tanpa membatasi jumlah aktual hasil yang dikembalikan.

Kueri di bawah ini berulang melalui halaman hasil berikutnya. Kueri ini menggunakan panggilan ExecuteQuery API untuk mengembalikan baris 51-100, di mana halaman hasil berikutnya ditentukan oleh next-token — dalam hal ini tokennya adalah:"H7kyGmvK376L".


aws iottwinmaker execute-query \
--workspace-id exampleWorkspace \
--query-statement "SELECT e FROM EntityGraph MATCH (e) LIMIT 500"\
--max-results 50
--next-token "H7kyGmvK376L"

next-tokenString menentukan halaman hasil berikutnya. Untuk informasi selengkapnya, lihat tindakan ExecuteQuery API.

AWS IoT TwinMaker query grafik pengetahuan memiliki batasan sebagai berikut:

Nama Batas	Kuota	Dapat Disesuaikan
Batas waktu eksekusi kueri	10 detik	Tidak
Jumlah maksimum hop	10	Ya
Jumlah maksimum diri `JOIN` s	20	Ya
Jumlah maksimum bidang yang diproyeksikan	20	Ya
Jumlah maksimum ekspresi kondisional (`AND`,`OR`,`NOT`)	10	Ya
Panjang maksimum pola `LIKE` ekspresi (termasuk wildcard dan escape)	20	Ya
Jumlah maksimum item yang dapat ditentukan dalam `IN` klausa	10	Ya
Nilai maksimum untuk `OFFSET`	3000	Ya
Nilai maksimum untuk `LIMIT`	3000	Ya
Nilai maksimum untuk lintasan (+) `OFFSET` `LIMIT`	3000	Ya

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Grafik pengetahuan panel Grafana

Sinkronisasi aset dengan AWS IoT SiteWise

AWS IoT TwinMaker grafik pengetahuan sumber daya tambahan

catatan