analyzeShardKey (comando de banco de dados)

Métricas sobre as características da chave do fragmento

keyCharacteristic consiste nas métricas sobre cardinalidade, frequência e monotonicidade da chave de fragmento. Essas métricas são retornadas somente quando keyCharacteristics é verdadeiro.

The metrics are calculated when analyzeShardKey command is run based on documents sampled from the collection. The calculation requires the shard key to have a supporting index. If there is no supporting index, no metrics are returned.

Você pode configurar a amostragem com os campos sampleRate e sampleSize. Ambos são opcionais, mas apenas um pode ser especificado. Quando sampleRate e sampleSize não são especificados, o MongoDB usa o valor do parâmetro analyzeShardKeyCharacteristicsDefaultSampleSize, que tem um valor padrão de 10 milhões.

Para calcular métricas com base em todos os documentos da collection, defina o sampleRate como 1.

Métricas sobre a distribuição de leitura e gravação

readWriteDistribution contém métricas sobre os padrões de roteamento de query e a proximidade dos intervalos de chaves de fragmento. Essas métricas são baseadas em query de amostra.

Para configurar a amostragem de consulta para uma coleção, use o comando configureQueryAnalyzer. As métricas de distribuição de leitura e gravar são retornadas somente se readWriteDistribution for true. As métricas são calculadas quando o comando analyzeShardKey é executado, utilizando as queries de leitura e de gravar de amostra. Se não houver queries de amostra, as métricas de distribuição de leitura e gravar não são retornadas.

• Se não houver amostras de query, o comando retornará writeDistribution , mas omitirá readDistribution.

• Se não houver amostras de query de gravação, o comando retornará readDistribution , mas omitirá writeDistribution.

To return read and write distribution metrics for a collection using analyzeShardKey, you must configure the query analyzer to sample the queries run on the collection. Otherwise, analyzeShardKey returns the read and write distribution metrics as 0 values. To configure the query analyzer, see configureQueryAnalyzer (database command).

Comportamento não bloqueante

analyzeShardKey o comando não bloqueia leituras ou gravações na coleção.

Amostragem de query

A qualidade das métricas sobre a distribuição de leitura e gravação é determinada pela representatividade da carga de trabalho quando ocorre a amostragem de query. Para alguns aplicativos, o retorno de métricas representativas pode exigir a saída da amostragem de query por vários dias.

Índices de apoio

O índice de suporte exigido pelo comando analyzeShardKey é diferente do índice de suporte exigido pelo comando shardCollection.

Esta tabela mostra o índice de suporte para a mesma chave de shard com hash para o comando analyzeShardKey e shardCollection:

Isso permite que você analise uma chave de fragmento que pode ainda não ter um índice de suporte necessário para fragmentá-la.

Tanto o comando analyzeShardKey quanto shardCollection têm os seguintes requisitos de índice:

• O índice tem um agrupamentosimples

• O índice não é multichave

• O índice não é escasso

• O índice não é parcial

Para criar índices de suporte, utilize o método db.collection.createIndex() .

readPreference

Para minimizar o desempenho, execute o comando analyzeShardKey com a preferência de leitura secondary ou secondaryPreferred . Em um cluster sharded, o mongos define automaticamente a preferência de leitura para secondaryPreferred se não for especificado.

Limitações

• You cannot run analyzeShardKey command on Atlas flex clusters.

• Você não pode executar o comando analyzeShardKey em implantações autônomas.

• Você não pode executar o comando analyzeShardKey diretamente em um conjunto de réplicas --shardsvr. Ao executar em um cluster sharded, o comando analyzeShardKey deve ser executado em um mongos.

• Você não pode executar o comando analyzeShardKey em coleção de séries temporais.

• Não é possível executar o comando analyzeShardKey em coleções com Queryable Encryption.

característicaschave

Esta é a estrutura do documento keyCharacteristics que é retornado quando keyCharacteristics é definido como true:

{
   keyCharacteristics: {
      numDocsTotal: <integer>,
      numOrphanDocs: <integer>,
      avgDocSizeBytes: <integer>,
      numDocsSampled: <integer>,
      isUnique: <bool>,
      numDistinctValues: <integer>,
      mostCommonValues: [
        { value: <shardkeyValue>, frequency: <integer> },
        ...
      ],
      monotonicity: {
        recordIdCorrelationCoefficient: <double>,
        type: "monotonic"|"not monotonic"|"unknown",
    }
  }
}

readWriteDistribution

Esta é a estrutura do documento que é retornada quando readWriteDistribution é definido como true:

{
   readDistribution: {
     sampleSize: {
       total: <integer>,
       find: <integer>,
       aggregate: <integer>,
       count: <integer>,
       distinct: <integer>
     },
     percentageOfSingleShardReads: <double>,
     percentageOfMultiShardReads: <double>,
     percentageOfScatterGatherReads: <double>,
     numReadsByRange: [
       <integer>,
       ...
     ]
   },
   writeDistribution: {
     sampleSize: {
       total: <integer>,
       update: <integer>,
       delete: <integer>,
       findAndModify: <integer>
     },
     percentageOfSingleShardWrites: <double>,
     percentageOfMultiShardWrites: <double>,
     percentageOfScatterGatherWrites: <double>,
     numWritesByRange: [
       <integer>,
       ...
     ],
     percentageOfShardKeyUpdates: <double>,
     percentageOfSingleWritesWithoutShardKey: <double>,
     percentageOfMultiWritesWithoutShardKey: <double>
   }
}

To return read and write distribution metrics for a collection using analyzeShardKey, you must configure the query analyzer to sample the queries run on the collection. Otherwise, analyzeShardKey returns the read and write distribution metrics as 0 values. To configure the query analyzer, see configureQueryAnalyzer (database command).

Informações básicas

• O aplicativo tem 1500 usuários.

• Existem 30 sobrenomes e 45 nomes, alguns mais comuns do que outros.

• Existem três usuários renomeados.

• Cada usuário segue exatamente cinco outros usuários e tem uma probabilidade muito alta de seguir pelo menos um usuário-celebridade.

Amostra de volume de trabalho

• Cada usuário publica cerca de duas publicações por dia em horários aleatórios. Eles editam cada publicação uma vez, logo após ser publicada.

• Cada usuário faz login a cada seis horas para ler seu próprio perfil e as publicações dos usuários que segue nas últimas 24 horas. Eles também respondem em uma postagem aleatória das últimas três horas.

• Para cada usuário, o aplicativo remove publicações com mais de três dias à meia-noite.

Padrões de query de volume de trabalho

Essa carga de trabalho tem os seguintes padrões de query:

• find comando com filtro { userId: , firstName: , lastName: }

• find comando com filtro { $or: [ { userId: , firstName: , lastName: , date: { $gte: } }, ... , { userId: , date: } ] }

• findAndModify comando com filtro { userId: , firstName: , lastName: , date: } para atualizar o corpo e o campo de data.

• update comando com multi: false e filtro { userId: , firstName: , lastName: , date: { $gte: , $lt: } } para atualizar o corpo e o campo de data.

• delete comando com multi: true e filtro { userId: , firstName: , lastName: , date: { $lt: } }

Abaixo estão métricas de exemplo retornadas pelo comando analyzeShardKey para algumas chaves de shard candidatas, com amostras de queries coletadas de sete dias de volume de trabalho.

{ _id: 1 } keyChaacteristics

Este exemplo utiliza o comando analyzeShardKey para fornecer métricas na chave de shard { _id: 1 } na collection social.post.

O seguinte bloco de código utiliza para ativar a amostragem de db.collection.configureQueryAnalyzer() query:

use social
db.post.configureQueryAnalyzer(
   {
      mode: "full",
      samplesPerSecond: 5
   }
)

Após o db.collection.configureQueryAnalyzer() coletar amostras de query, o seguinte bloco de código utiliza o comando analyzeShardKey para amostrar documentos do 10,000 e calcular resultados:

use social
db.post.analyzeShardKey(
   { _id: 1 },
   {
      keyCharacteristics: true,
      readWriteDistribution: false,
      sampleSize: 10000
   }
)

{ lastName: 1 } keyChaacteristics

Este analyzeShardKey comando fornece métricas na { lastName: 1 } chave de shard na social.post collection :

use social
db.post.analyzeShardKey(
   { lastName: 1 },
   {
      keyCharacteristics: true,
      readWriteDistribution: false
   }
)

A saída deste exemplo se assemelha ao seguinte:

{
   "keyCharacteristics": {
     "numDocsTotal" : 9039,
     "avgDocSizeBytes" : 153,
     "numDocsSampled" : 9039,
     "isUnique" : false,
     "numDistinctValues" : 30,
     "mostCommonValues" : [
         {
           "value" : {
               "lastName" : "Smith"
           },
           "frequency" : 1013
         },
         {
           "value" : {
               "lastName" : "Johnson"
           },
           "frequency" : 984
         },
         {
           "value" : {
               "lastName" : "Jones"
           },
           "frequency" : 962
         },
         {
           "value" : {
               "lastName" : "Brown"
           },
           "frequency" : 925
         },
         {
           "value" : {
               "lastName" : "Davies"
           },
           "frequency" : 852
         }
     ],
     "monotonicity" : {
       "recordIdCorrelationCoefficient" : 0.0771959161,
       "type" : "not monotonic"
   },
 }
}

{ userId: 1 } keyChaacteristics

Este analyzeShardKey comando fornece métricas na { userId: 1 } chave de shard na social.post collection :

use social
db.post.analyzeShardKey(
   { userId: 1 },
   {
      keyCharacteristics: true,
      readWriteDistribution: false
   }
)

A saída deste exemplo se assemelha ao seguinte:

{
  "keyCharacteristics": {
    "numDocsTotal" : 9039,
    "avgDocSizeBytes" : 162,
    "numDocsSampled" : 9039,
    "isUnique" : false,
    "numDistinctValues" : 1495,
    "mostCommonValues" : [
      {
        "value" : {
          "userId" : UUID("aadc3943-9402-4072-aae6-ad551359c596")
        },
        "frequency" : 15
      },
     {
       "value" : {
         "userId" : UUID("681abd2b-7a27-490c-b712-e544346f8d07")
       },
       "frequency" : 14
     },
     {
       "value" : {
         "userId" : UUID("714cb722-aa27-420a-8d63-0d5db962390d")
       },
       "frequency" : 14
     },
     {
       "value" : {
         "userId" : UUID("019a4118-b0d3-41d5-9c0a-764338b7e9d1")
       },
       "frequency" : 14
     },
     {
       "value" : {
         "userId" : UUID("b9c9fbea-3c12-41aa-bc69-eb316047a790")
       },
       "frequency" : 14
     }
   ],
   "monotonicity" : {
     "recordIdCorrelationCoefficient" : -0.0032039729,
     "type" : "not monotonic"
   },
 }
}

{ userId: 1 } readWriteDistribution

Este analyzeShardKey comando fornece métricas na { userId: 1 } chave de shard na social.post collection :

use social
db.post.analyzeShardKey(
   { userId: 1 },
   {
      keyCharacteristics: false,
      readWriteDistribution: true
   }
)

A saída deste exemplo se assemelha ao seguinte:

{
   "readDistribution" : {
     "sampleSize" : {
       "total" : 61363,
       "find" : 61363,
       "aggregate" : 0,
       "count" : 0,
       "distinct" : 0
     },
     "percentageOfSingleShardReads" : 50.0008148233,
     "percentageOfMultiShardReads" : 49.9991851768,
     "percentageOfScatterGatherReads" : 0,
     "numReadsByRange" : [
       688,
       775,
       737,
       776,
       652,
       671,
       1332,
       1407,
       535,
       428,
       985,
       573,
       1496,
       ...
       ],
     },
   "writeDistribution" : {
     "sampleSize" : {
       "total" : 49638,
       "update" : 30680,
       "delete" : 7500,
       "findAndModify" : 11458
     },
     "percentageOfSingleShardWrites" : 100,
     "percentageOfMultiShardWrites" : 0,
     "percentageOfScatterGatherWrites" : 0,
     "numWritesByRange" : [
       389,
       601,
       430,
       454,
       462,
       421,
       668,
       833,
       493,
       300,
       683,
       460,
       ...
      ],
      "percentageOfShardKeyUpdates" : 0,
      "percentageOfSingleWritesWithoutShardKey" : 0,
      "percentageOfMultiWritesWithoutShardKey" : 0
    }
}