Compartilhar via

labels() (função graph na versão prévia)

Aplica-se a: ✅Microsoft Fabric✅Azure Data Explorer

Observação

Esse recurso está atualmente em versão prévia pública. A funcionalidade e a sintaxe estão sujeitas a alterações antes da Disponibilidade Geral.

A labels() função de grafo recupera os rótulos associados a nós ou bordas em um grafo. Ele pode ser usado para filtrar elementos com base em seus rótulos e para projetar informações de rótulo nos resultados da consulta.

Os rótulos são definidos em modelos do Graph e podem ser estáticos (rótulos fixos atribuídos a tipos de nó ou borda) ou dinâmicos (rótulos derivados de propriedades de dados durante a construção do grafo). A labels() função acessa esses rótulos predefinidos para habilitar a filtragem e a análise eficientes de elementos de grafo.

Observação

Essa função é usada com os operadores graph-match e graph-shortest-paths .

Importante

Quando a labels() função é usada em um grafo criado com o make-graph operador (ou seja, um grafo transitório em vez de um modelo de grafo persistente), ela sempre retorna uma matriz vazia (de tipo de dados dinâmico) para todos os nós e bordas, pois grafos transitórios não têm metadados de rótulo.

Sintaxe

labels([element])

Parâmetros

Nome Tipo Obrigatório Descrição
elemento string A referência a um nó de grafo ou variável de borda em um padrão de grafo. Não passe parâmetros quando usados em todas as funções de grafo all(), any()e map(), com inner_nodes(). Para obter mais informações, consulte a notação de padrão do Graph.

Devoluções

Retorna uma matriz dinâmica que contém os rótulos associados ao nó ou à borda especificados. Para nós e bordas sem rótulos, retorna uma matriz vazia.

Quando usado dentro de all(), any()ou map() com inner_nodes(), chame labels() sem parâmetros para retornar os rótulos para todos os nós ou bordas internas, respectivamente.

Fontes de rótulo

Os rótulos são definidos em modelos do Graph e podem ser originados de duas fontes:

  • Rótulos estáticos: rótulos fixos atribuídos a tipos de nó ou borda específicos durante a definição do modelo de grafo. Esses rótulos permanecem constantes para todas as instâncias de um tipo específico.
  • Rótulos dinâmicos: rótulos derivados de propriedades de dados durante a construção do grafo. Esses rótulos podem variar com base nos valores de dados reais e expressões computadas.

A labels() função recupera rótulos estáticos e dinâmicos associados a elementos de grafo por meio do esquema e definição do modelo de grafo.

Exemplos

Filtrar nós por rótulos

O exemplo a seguir mostra como usar a labels() função para filtrar nós com base em seus rótulos atribuídos. O exemplo inclui a definição completa do modelo de grafo para esclarecer como os rótulos estáticos e dinâmicos são atribuídos.

Definição de modelo de grafo

.create-or-alter graph_model AppProcessGraph ```
{
  "Schema": {
    "Nodes": {
      "Application": {"AppName": "string", "Type": "string"},
      "Process": {"ProcessName": "string"}
    },
    "Edges": {
      "CONNECTS_TO": {}
    }
  },
  "Definition": {
    "Steps": [
      {
        "Kind": "AddNodes",
        "Query": "Applications | project AppId, AppName, Type, NodeLabels",
        "NodeIdColumn": "AppId",
        "Labels": ["Application"],
        "LabelsColumn": "NodeLabels"
      },
      {
        "Kind": "AddNodes",
        "Query": "Processes | project ProcId, ProcessName",
        "NodeIdColumn": "ProcId",
        "Labels": ["Process"]
      },
      {
        "Kind": "AddEdges",
        "Query": "AppConnections | project SourceAppId, TargetProcId",
        "SourceColumn": "SourceAppId",
        "TargetColumn": "TargetProcId",
        "Labels": ["CONNECTS_TO"]
      }
    ]
  }
}
```

Exemplo de consulta

graph('AppProcessGraph')
| graph-match cycles=none (app)-[e*1..3]->(process)
    where process.ProcessName contains "nginx" and labels(app) has "Application"
    project app=app.AppName
| summarize c=count() by app
| top 10 by c desc

Saída

aplicativo c
WebApp1 15
WebApp2 12
APIService oito

Rótulos de projeto em resultados

O exemplo a seguir demonstra como usar a labels() função na cláusula de projeto para incluir informações de rótulo nos resultados da consulta. Essa consulta localiza conexões entre diferentes tipos de componentes de rede e inclui seus rótulos para análise.

Definição de modelo de grafo

.create-or-alter graph_model NetworkGraph ```
{
  "Schema": {
    "Nodes": {
      "NetworkComponent": {"ComponentName": "string", "ComponentType": "string"}
    },
    "Edges": {
      "CONNECTED_TO": {"ConnectionType": "string"}
    }
  },
  "Definition": {
    "Steps": [
      {
        "Kind": "AddNodes",
        "Query": "NetworkComponentsTable | project Id, ComponentName, ComponentType, NodeLabels",
        "NodeIdColumn": "Id",
        "Labels": ["NetworkComponent"],
        "LabelsColumn": "NodeLabels"
      },
      {
        "Kind": "AddEdges",
        "Query": "ConnectionsTable | project SourceId, TargetId, ConnectionType, EdgeLabels",
        "SourceColumn": "SourceId",
        "TargetColumn": "TargetId",
        "Labels": ["CONNECTED_TO"],
        "LabelsColumn": "EdgeLabels"
      }
    ]
  }
}
```

Exemplo de consulta

graph('NetworkGraph')
| graph-match (source)-[conn]->(target)
    where labels(source) has "Network" and labels(target) has "Compute"
    project 
        SourceComponent = source.ComponentName,
        TargetComponent = target.ComponentName,
        SourceLabels = labels(source),
        TargetLabels = labels(target),
        ConnectionType = conn.ConnectionType

Saída

Componente de origem TargetComponent SourceLabels TargetLabels Tipo de Conexão
Comutador1 Servidor1 ["Rede", "Acesso"] ["Computação", "Produção"] Ethernet

Filtrar por várias condições de rótulo

O exemplo a seguir mostra como combinar várias condições de rótulo para encontrar padrões complexos em uma topologia de rede. Essa consulta identifica caminhos de componentes de front-end a componentes de back-end por meio de camadas de middleware.

Definição de modelo de grafo

.create-or-alter graph_model AppComponentGraph ```
{
  "Schema": {
    "Nodes": {
      "Frontend": {"ComponentName": "string"},
      "Middleware": {"ComponentName": "string"},
      "Backend": {"ComponentName": "string"}
    },
    "Edges": {
      "DEPENDS_ON": {"DependencyType": "string"}
    }
  },
  "Definition": {
    "Steps": [
      {
        "Kind": "AddNodes",
        "Query": "ComponentsTable | project Id, ComponentName, NodeLabels",
        "NodeIdColumn": "Id",
        "LabelsColumn": "NodeLabels"
      },
      {
        "Kind": "AddEdges",
        "Query": "DependenciesTable | project SourceId, TargetId, DependencyType, EdgeLabels",
        "SourceColumn": "SourceId",
        "TargetColumn": "TargetId",
        "Labels": ["DEPENDS_ON"],
        "LabelsColumn": "EdgeLabels"
      }
    ]
  }
}
```

Exemplo de consulta

graph('AppComponentGraph')
| graph-match (frontend)-[dep1]->(middleware)-[dep2]->(backend)
    where labels(frontend) has "Frontend" 
          and labels(middleware) has "Middleware" 
          and labels(backend) has "Backend"
    project 
        Path = strcat(frontend.ComponentName, " -> ", middleware.ComponentName, " -> ", backend.ComponentName),
        FrontendLabels = labels(frontend),
        MiddlewareLabels = labels(middleware),
        BackendLabels = labels(backend)

Saída

Caminho FrontendLabels MiddlewareLabels BackendLabels
WebUI –> APIGateway –> Banco de dados ["Frontend", "UserInterface"] ["Middleware", "API"] ["Back-end", "Armazenamento"]
WebUI –> APIGateway –> Cache ["Frontend", "UserInterface"] ["Middleware", "API"] ["Back-end", "Cache"]

Usar rótulos() com funções all() e any()

O exemplo a seguir demonstra como usar a labels() função sem parâmetros dentro all() e any() funções com caminhos de comprimento variável. Essa consulta localiza caminhos em uma malha de serviço em que todos os serviços intermediários têm rótulos "Produção" e pelo menos um serviço intermediário tem rótulos "Críticos".

Definição de modelo de grafo

.create-or-alter graph_model ServiceMeshGraph ```
{
  "Schema": {
    "Nodes": {
      "Service": {"ServiceName": "string", "Environment": "string"}
    },
    "Edges": {
      "CALLS": {"Protocol": "string"}
    }
  },
  "Definition": {
    "Steps": [
      {
        "Kind": "AddNodes",
        "Query": "ServicesTable | project Id, ServiceName, Environment, NodeLabels",
        "NodeIdColumn": "Id",
        "Labels": ["Service"],
        "LabelsColumn": "NodeLabels"
      },
      {
        "Kind": "AddEdges",
        "Query": "ServiceCallsTable | project SourceId, TargetId, Protocol, EdgeLabels",
        "SourceColumn": "SourceId",
        "TargetColumn": "TargetId",
        "Labels": ["CALLS"],
        "LabelsColumn": "EdgeLabels"
      }
    ]
  }
}
```

Exemplo de consulta

graph('ServiceMeshGraph')
| graph-match (source)-[calls*2..4]->(destination)
    where source.ServiceName == "UserService" and
          destination.ServiceName == "DatabaseService" and
          all(inner_nodes(calls), labels() has "Production") and
          any(inner_nodes(calls), labels() has "Critical")
    project 
        Path = strcat_array(map(inner_nodes(calls), ServiceName), " -> "),
        IntermediateLabels = map(inner_nodes(calls), labels()),
        CallProtocols = map(calls, Protocol)

Saída

Caminho IntermediateLabels CallProtocols
AuthService –> PaymentService [["Produção", "Autenticação"], ["Produção", "Crítico", "Pagamento"]] ["HTTPS", "gRPC"]
CacheService –> PaymentService [["Produção", "Cache"], ["Produção", "Crítico", "Pagamento"]] ["Redis", "gRPC"]

Conteúdo relacionado