AWS IoT TwinMaker conocimiento, gráfico, recursos adicionales

Obtenga todas las entidades con un filtro

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

Esta consulta devuelve todas las entidades de un espacio de trabajo con el nombreroom_0.

FROMcláusula: EntityGraph es la colección de gráficos que contiene todas las entidades y sus relaciones en un espacio de trabajo. Esta colección se crea y administra automáticamente en AWS IoT TwinMaker función de las entidades de tu espacio de trabajo.

Cláusula MATCH: especifica un patrón que coincide con una parte del gráfico. En este caso, el patrón (entity) coincide con todos los nodos del gráfico y está vinculado a la variable de entidad. La cláusula FROM debe ir seguida de la cláusula MATCH.

WHEREcláusula: especifica un filtro en el entityName campo del nodo, donde el valor debe coincidirroom_0.

SELECTcláusula: especifica la entity variable para que se devuelva todo el nodo de la entidad.

Respuesta:

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

columnDescriptionsDevuelve los metadatos sobre la columna, como el nombre y el tipo. El tipo devuelto es NODE. Esto indica que se ha devuelto todo el nodo. Otros valores del tipo pueden EDGE indicar una relación o VALUE indicar un valor escalar, como un entero o una cadena.

rows devuelve una lista de filas. Como solo coincidió una entidad, se devuelve un rowData que contiene todos los campos de una entidad.

Cada nodo contiene todos los campos de nivel de entidadentityId, como, arn y los campos de nivel de componentecomponents, como, por ejemplo, y los campos de nivel de propiedadcomponentName, properties como componentTypeId y, todo ello como un JSON propertyName anidado. propertyValue

Obtenga todas las relaciones con un filtro:

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

Esta consulta devuelve todas las relaciones de un espacio de trabajo con el nombre de la relación isLocationOf.

La MATCH cláusula: especifica un patrón que coincide con dos nodos (indicados con()) que están conectados por un borde dirigido (indicado con-[]->) y enlazados a una variable denominada. relationship

La WHERE cláusula: especifica un filtro en el relationshipName campo del borde, donde está el valorisLocationOf.

Cláusula SELECT: especifica la variable de relación para que se devuelva todo el nodo de borde.

Respuesta

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

El tipo de columna en columnDescriptions es unEDGE.

Cada uno rowData representa un borde con campos comorelationshipName. Es el mismo que el nombre de la propiedad de la relación definido en la entidad. El sourceEntityId sourceComponentName y sourceComponentTypeId proporcionan información sobre la entidad y el componente en los que se definió la propiedad de la relación. targetEntityIdEspecifica a qué entidad apunta esta relación.

Obtiene todas las entidades con una relación específica con una entidad específica

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

Esta consulta devuelve todos los nombres de entidad de todas las entidades que tienen una isLocationOf relación con la room_0 entidad.

La MATCH cláusula: especifica un patrón que coincide con dos nodos (e1,e2) que tengan un borde dirigido (r).

Cláusula WHERE: especifica un filtro en el nombre de la relación y el nombre de la entidad de origen.

La SELECT cláusula: devuelve el entityName campo del e2 nodo.

Respuesta

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

En ColumnDescriptions, el tipo de columna es, VALUE ya que entityName es una cadena.

Se devuelve una entidadfloor_0,.

Haga coincidir el nodo 'b' que apunta al nodo 'a':

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

Haga coincidir el nodo 'a' que apunta al nodo 'b':

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

No hay ninguna variable vinculada a una relación, suponiendo que no es necesario especificar un filtro en la relación.

Haga coincidir el nodo 'a' que apunta al nodo 'b' y el nodo 'b' que apunta al nodo 'a':

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

Esto devolverá dos coincidencias: una entre «a» y «b» y otra entre «b» y «a», por lo que se recomienda utilizar bordes dirigidos siempre que sea posible.

El nombre de la relación también es una etiqueta del gráfico de propiedadesEntityGraph, por lo que simplemente puede especificar el nombre de la relación después de dos puntos (:)) en lugar de especificar un filtro rel.relationshipName en la WHERE cláusula.

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

Encadenamiento: los patrones se pueden encadenar para que coincidan en varias relaciones.

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

Los patrones de saltos variables también pueden abarcar varios nodos y bordes:

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

Esta consulta coincide con cualquier patrón con bordes salientes del nodo 'a' entre 1 y 5 saltos. Los cuantificadores permitidos son:

{m,n}: entre m y n repeticiones

{m,}: m o más repeticiones.

Devuelve un nodo:

SELECT e
FROM EntityGraph MATCH (e)

Devuelve una ventaja:

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

Devuelve un valor escalar:

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

Formatee el nombre del campo de salida asignándole un alias con AS. Aquí, en lugar de propertyValue como nombre de columna en la respuesta, se devuelve roomfunction.

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

Se recomienda encarecidamente el uso de alias para que sea explícito, aumente la legibilidad y evite cualquier ambigüedad en las consultas.

Los operadores lógicos admitidos sonAND, y. NOT OR

Los operadores de comparación compatibles son <, <=, >, =>, = y !=.

Utilice la IN palabra clave si desea especificar varias OR condiciones en el mismo campo.

Filtre por un campo de entidad, componente o propiedad:

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 la configuration propiedad. Esta unit es la clave en el mapa de configuración y Celsius el valor.

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

Compruebe si una propiedad del mapa contiene una clave y un valor determinados:

WHERE p.propertyValue.length = 20.0

Compruebe si una propiedad del mapa contiene una clave determinada:

WHERE NOT p.propertyValue.length IS MISSING

Compruebe si una propiedad de la lista contiene un valor determinado:

WHERE 10.0 IN p.propertyValue

Utilice la función lower() para realizar comparaciones que no distingan mayúsculas de minúsculas. De forma predeterminada, la comparación distingue entre mayúsculas y minúsculas.

WHERE lower(p.propertyValue) = 'meeting'

Búsqueda de infijos: %room%

Búsqueda de prefijos: room%

Búsqueda de sufijos: %room

Si tiene '%' en sus valores, coloque un carácter de escape en LIKE y especifique el carácter de escape conESCAPE.

La palabra clave DISTINCT elimina los duplicados del resultado final.

DISTINCT no se admite en tipos de datos complejos.

La COUNT palabra clave calcula el número de elementos del resultado de una consulta.

COUNTno se admite en campos complejos anidados ni en campos de patrones gráficos.

COUNTno se admite la agregación con DISTINCT consultas anidadas.

Por ejemplo, COUNT(DISTINCT e.entityId) no se admite.

Consultas de salto variable

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

Esta consulta busca y proyecta los metadatos de los nodos de cualquier patrón con bordes salientes del nodo a en un intervalo de 1 a 3 saltos.

Consultas de saltos fijos

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

Esta consulta compara y proyecta los metadatos de las entidades y los bordes entrantes en b.

Consultas no dirigidas

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

Esta consulta busca y proyecta los metadatos de los nodos en patrones de 1 salto que conectan a y c a través de 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"
                        }
                    ]
                }
            ]
        }
    ]
}

Esta respuesta a la PATH consulta se compone únicamente de metadatos que identifican todos los nodos y bordes de cada uno path/pattern entre a y c mediante b.

La LIMIT palabra clave afecta a la consulta y limita las filas resultantes. Si necesitas controlar la cantidad de resultados devueltos por llamada a la API sin limitar la cantidad total de resultados devueltos, usaLIMIT.

max-resultses un parámetro opcional para la acción de la ExecuteQuery API. max-resultssolo se aplica a la API y al modo en que se leen los resultados dentro de los límites de la consulta anterior.

El uso max-results en una consulta permite reducir el número de resultados mostrados sin limitar el número real de resultados devueltos.

La next-token cadena especifica la siguiente página de resultados. Para obtener más información, consulte la acción ExecuteQuery de la API.