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 loro relazioni in uno spazio di lavoro. Questa raccolta viene creata e gestita automaticamente in AWS IoT TwinMaker base alle entità presenti nell'area di lavoro.

MATCHclausola: specifica un modello che corrisponde a una parte del grafico. In questo caso, il pattern (entity) corrisponde a ogni nodo 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, dove 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 relativi alla colonna, come il nome e il tipo. Il tipo restituito èNODE. Ciò indica che l'intero nodo è stato restituito. 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àentityId, arn ad esempio i campi a livello di componentecomponents, nonché i campi a livello di proprietà properties come componentTypeId ecomponentName, il tutto 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 un'area di lavoro con il nome isLocationOf della relazione.

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

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

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

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 simili arelationshipName. È lo stesso nome della proprietà di relazione definita nell'entità. sourceComponentNamee sourceComponentTypeId forniscono informazioni sull'entità e sul componente su cui è stata definita la proprietà della relazione. sourceEntityId targetEntityIdSpecificano a quale entità è rivolta 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 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 since 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 alcuna variabile associata a una relazione, presupponendo che non sia necessario specificare un filtro sulla 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 l'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 modelli possono essere concatenati in modo da corrispondere su più relazioni.

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

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

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

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

{m,n}- tra m e n ripetizioni

{m,}- m o più ripetizioni.

Restituisce 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 sono ANDNOT, eOR.

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

Utilizzate la IN parola chiave se desiderate specificare più OR condizioni sullo stesso campo.

Filtra in base a un'entità, un componente o un campo di 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'

Filtro 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 determinata chiave e un valore:

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à dell'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 Infix: %room%

Ricerca con prefisso: room%

Ricerca con suffissi: %room

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

La DISTINCT parola chiave elimina i duplicati dal risultato finale.

DISTINCTnon è supportato su tipi di dati complessi.

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

COUNTnon è supportato nei campi complessi annidati e nei campi con pattern grafici.

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

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

Query a hop variabile

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

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

Interrogazioni a hop fisso

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

Questa query abbina e proietta i metadati delle entità e dei bordi in entrata su b.

Interrogazioni non indirizzate

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

Questa query abbina e proietta i metadati dei nodi in modelli 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 comprende solo metadati che identificano tutti i nodi e i bordi di ciascuno path/pattern tra a e c tramite b.

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

max-resultsè un parametro opzionale per l'azione dell'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 ExecuteQueryAPI.