AWS IoT TwinMaker Knowledge Graph: risorse aggiuntive

Ottieni tutte le entità con un filtro

SELECT entity
FROM EntityGraph MATCH (entity)
WHERE entity.entityName = 'room_0'

Questa query restituisce tutte le entità in uno spazio di lavoro con il nomeroom_0.

FROMclausola: EntityGraph è la raccolta di grafici che contiene tutte le entità e le relative relazioni in uno spazio di lavoro. Questa raccolta viene creata e gestita automaticamente in AWS IoT TwinMaker base alle entità presenti nel tuo spazio di lavoro.

MATCHclausola: specifica un modello che corrisponde a una parte del grafico. In questo caso, il pattern (entity) corrisponde a tutti i nodi del grafico ed è associato alla variabile di entità. La FROM clausola deve essere seguita dalla MATCH clausola.

WHEREclausola: specifica un filtro sul entityName campo del nodo, in cui il valore deve corrispondere. room_0

SELECTclausola: specifica la entity variabile in modo che venga restituito l'intero nodo dell'entità.

Risposta:

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

columnDescriptionsRestituisce i metadati sulla colonna, come il nome e il tipo. Il tipo restituito è. NODE Ciò indica che è stato restituito l'intero nodo. Altri valori per il tipo possono essere quelli EDGE che indicherebbero una relazione o VALUE che indicherebbero un valore scalare come un numero intero o una stringa.

rowsRestituisce un elenco di righe. Poiché è stata trovata una sola entità, ne rowData viene restituita una che contiene tutti i campi di un'entità.

Ogni nodo contiene tutti i campi a livello di entità come arn e entityIdcomponents, i campi a livello di componente come e i campi a livello di proprietà come componentTypeId ecomponentName, tutti properties come JSON annidato. propertyName propertyValue

Ottieni tutte le relazioni con un filtro:

SELECT relationship
FROM EntityGraph MATCH (e1)-[relationship]->(e2)
WHERE relationship.relationshipName = 'isLocationOf'

Questa query restituisce tutte le relazioni in uno spazio di lavoro con il nome isLocationOf della relazione.

La MATCH clausola: specifica uno schema che corrisponde a due nodi (indicati da()) collegati da un bordo diretto (indicato da-[]->) e legati a una variabile chiamata. relationship

La WHERE clausola: specifica un filtro sul relationshipName campo del bordo, dove si trova il valore. isLocationOf

La SELECT clausola: specifica la variabile di relazione in modo che venga restituito l'intero nodo edge.

Risposta

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

Il tipo di colonna in columnDescriptions è un. EDGE

Ciascuno rowData rappresenta un bordo con campi comerelationshipName. È lo stesso del nome della proprietà di relazione definito nell'entità. IlsourceEntityId, sourceComponentName e sourceComponentTypeId fornisce informazioni sull'entità e sul componente su cui è stata definita la proprietà della relazione. targetEntityIdSpecifica a quale entità è indirizzata questa relazione.

Ottieni tutte le entità con una relazione specifica con un'entità specifica

SELECT e2.entityName
      FROM EntityGraph MATCH (e1)-[r]->(e2)
      WHERE relationship.relationshipName = 'isLocationOf'
      AND e1.entityName = 'room_0'

Questa query restituisce tutti i nomi di entità di tutte le entità che hanno una isLocationOf relazione con l'room_0entità.

La MATCH clausola: specifica un modello che corrisponde a due nodi qualsiasi (e1,e2) con un bordo diretto (r).

La WHERE clausola: specifica un filtro sul nome della relazione e sul nome dell'entità di origine.

La SELECT clausola: restituisce il entityName campo nel nodo. e2

Risposta

{
  "columnDescriptions": [
    {
       "name": "entityName",
       "type": "VALUE"
    }
  ],
   "rows": [
    {
       "rowData": [
         "floor_0"
      ]
    }
  ]
}

In ColumnDescriptions, il tipo di colonna è VALUE poiché entityName è una stringa.

Viene restituita un'entità. floor_0

Abbina il nodo «b» che punta al nodo «a»:

FROM EntityGraph MATCH (a)-[rel]-(b)

Abbina il nodo «a» che punta al nodo «b»:

FROM EntityGraph MATCH (a)-[]->(b)

Non esiste una variabile associata a una relazione, supponendo che non sia necessario specificare un filtro nella relazione.

Abbina il nodo «a» che punta al nodo «b» e il nodo «b» che punta al nodo «a»:

FROM EntityGraph MATCH (a)-[rel]-(b)

Ciò restituirà due corrispondenze: una da «a» a «b» e un'altra da «b» a «a», quindi la raccomandazione è di utilizzare bordi diretti ove possibile.

Il nome della relazione è anche un'etichetta del grafico delle proprietàEntityGraph, quindi puoi semplicemente specificare il nome della relazione dopo i due punti (:)) invece di specificare un filtro rel.relationshipName nella WHERE clausola.

FROM EntityGraph MATCH (a)-[:isLocationOf]-(b)

Concatenamento: i pattern possono essere concatenati in modo che corrispondano su più relazioni.

FROM EntityGraph MATCH (a)-[rel1]->(b)-[rel2]-(c)

I pattern di hop variabili possono estendersi anche su più nodi e bordi:

FROM EntityGraph MATCH (a)-[]->{1,5}(b)

Questa query corrisponde a qualsiasi modello con bordi in uscita dal nodo 'a' entro 1-5 hop. I quantificatori consentiti sono:

{m,n}- tra m e n ripetizioni

{m,}- m o più ripetizioni.

Restituisci un nodo:

SELECT e
FROM EntityGraph MATCH (e)

Restituisci un bordo:

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

Restituisce un valore scalare:

SELECT floor.entityName, room.description, p.propertyValue AS roomfunction
FROM EntityGraph MATCH (floor)-[:isLocationOf]-(room),
room.components AS c, c.properties AS p

Formatta il nome del campo di output assegnandogli un alias utilizzando. AS Qui, invece che propertyValue come nome di colonna nella risposta, roomfunction viene restituito.

Alias di ritorno:

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%'

Si consiglia vivamente di utilizzare gli alias per essere espliciti, aumentare la leggibilità ed evitare ambiguità nelle query.

Gli operatori logici supportati sonoAND,NOT, eOR.

Gli operatori di confronto supportati sono < <=>,=>,=, e!=.

Usa la IN parola chiave se desideri specificare più OR condizioni sullo stesso campo.

Filtra in base a un campo di entità, componente o proprietà:

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'

Filtra sulla configuration proprietà. unitEcco la chiave nella mappa di configurazione ed Celsius è il valore.

WHERE p.definition.configuration.unit = 'Celsius'

Controlla se una proprietà della mappa contiene una chiave e un valore determinati:

WHERE p.propertyValue.length = 20.0

Controlla se una proprietà della mappa contiene una determinata chiave:

WHERE NOT p.propertyValue.length IS MISSING

Controlla se una proprietà di elenco contiene un determinato valore:

WHERE 10.0 IN p.propertyValue

Usa la lower() funzione per i confronti senza distinzione tra maiuscole e minuscole. Per impostazione predefinita, tutti i confronti fanno distinzione tra maiuscole e minuscole.

WHERE lower(p.propertyValue) = 'meeting'

Ricerca infissa: %room%

Ricerca per prefisso: room%

Ricerca per suffissi: %room

Se hai '%' nei tuoi valori, inserisci un carattere di escape LIKE e specifica il carattere di escape conESCAPE.

La DISTINCT parola chiave elimina i duplicati dal risultato finale.

DISTINCTnon è supportata su tipi di dati complessi.

La COUNT parola chiave calcola il numero di elementi nel risultato di una query.

COUNTnon è supportata nei campi complessi annidati e nei campi con pattern grafico.

COUNTl'aggregazione non è supportata con le query DISTINCT annidate.

Ad esempio, COUNT(DISTINCT e.entityId) non è supportato.

Interrogazioni con hop variabile

SELECT p FROM EntityGraph MATCH p = (a)-[]->{1, 3}(b)

Questa query abbina e proietta i metadati dei nodi di qualsiasi pattern con bordi in uscita dal nodo a entro 1-3 hop.

Query con hop fisso

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

Questa query abbina e proietta i metadati delle entità e degli spigoli in entrata su b.

Interrogazioni non indirizzate

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

Questa query corrisponde e proietta i metadati dei nodi in schemi a 1 hop che collegano a e c tramite 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"
                        }
                    ]
                }
            ]
        }
    ]
}

Questa risposta alla PATH query è composta solo da metadati che identificano tutti i nodi e gli spigoli di ciascuno path/pattern tra a e c via b.

La LIMIT parola chiave influisce sulla query e limita le righe risultanti. Se devi controllare il numero di risultati restituiti per chiamata API senza limitare il numero totale di risultati restituiti, usaLIMIT.

max-resultsè un parametro opzionale per l'azione ExecuteQuery API. max-resultssi applica solo all'API e al modo in cui i risultati vengono letti entro i limiti della query precedente.

L'utilizzo max-results in una query consente di ridurre il numero di risultati visualizzati senza limitare il numero effettivo di risultati restituiti.

La next-token stringa specifica la pagina successiva dei risultati. Per ulteriori informazioni, consulta l'azione ExecuteQuery API.