Dica 1: Use as teclas de uso
Se você conhecer o Documento Id/Key do documento, você deve aproveitar a USE KEYS cláusula. Isso elimina o Serviço de Indexação (deixando de lado, portanto, a rede, os scans, os resultados de indexação e o processamento) – é a funcionalidade mais próxima do que você tem no lado do N1QL, comparável a uma busca KV. O otimizador usará o KeyScan quando você usar a USE KEYS em vez de uma busca Index ou Primary. Quando a chave for conhecida e for necessária a consulta de todo o documento, sempre priorize essa opção. USE KEYS Sobre um META().id scan de índice.
SELECT * FROM `travel-sample` USING KEYS ["landmark_37588"];
Você pode especificar vários valores em USE KEYS se você estiver fazendo consulta para vários documentos.
SELECT * FROM `travel-sample` USING KEYS ["landmark_37588", "landmark_37603" ];
Junte-se As operações também são realizadas usando as chaves de documento.
SELECT * FROM ORDERS ou INNER JOIN CUSTOMER c ON KEYS o.id;
SELECT * FROM ORDERS O UTILIZAR A KEYS ["ord:382"] INNER JOIN CUSTOMER c ON KEYS o.id;
Como essa consulta está realizando uma GET de KV() via N1QL, seria ainda mais eficiente ignorar o N1QL completamente e fazer uma GET de KV() diretamente via o SDK. bucket.get("landmark_37588")
Note que ao selecionar um ou mais campos específicos, uma consulta por índice abrangente pode ser mais rápida do que a execução do serviço de obtenção de dados quando se trabalha com documentos grandes ou uma longa lista de chaves.
Dica 2: Não indexe valores que sejam um predicado de igualdade do índice
Remova quaisquer chaves/expressões de índice que estejam listadas tanto no índice quanto nos índices. ONDE declaração como predicado de igualdade. Esses valores teriam cardinalidade zero e não precisam ser indexados, pois isso resultaria em índices mais lentos; eles simplesmente precisam impedir que documentos que não satisfaçam a condição sejam adicionados ao índice. Os serviços de consulta/indexação são inteligentes o suficiente para entender uma consulta e cobrir automaticamente valores presentes como predicado de igualdade no índice.
Considere a seguinte consulta:
SELECT userId, firstName, lastName
DE E-COMMERCE
WHERE docType = "user" AND username = "johnsmith21"
Agora considere os seguintes índices, que satisfarão toda a consulta acima:
CREATE INDEX idx_usernames ON ecommerce(docType, username)
Este índice emite ambos docType e nome de usuário no índice. Além disso, nome de usuário mais exclusivo, mas você esperaria que esse índice contivesse apenas documentos de “usuário”. No entanto, esse índice contaria com uma entrada para cada único documento no qual o documento tinha um docType propriedade, independentemente de ela possuir ou não nome de usuário a propriedade só precisa ser qualificada se a chave principal estiver presente. Pense nisso: a chave principal deve ter SE O DOCTYPE NÃO FOR FALTO declaração.
CREATE INDEX idx_usernames ON ecommerce(username, docType)
Este índice limitaria com sucesso o alcance dos índices apenas aos documentos que contivessem uma nome de usuário propriedade, mas novamente isso não é garantido. Poderíamos filtrar o índice adicionando um WHERE docType = "user" predicado:
CREATE INDEX idx_usernames ON ecommerce(username, docType)
WHERE docType = "user"
No entanto, ao ter o docType quando o valor emitido para o índice for apenas um único valor, isso é apenas um desperdício de bytes.
CREATE INDEX idx_usernames ON ecommerce(username)
WHERE docType = "user"
Esta é a melhor opção de todos os índices acima, pois eliminará qualquer documento que não atenda aos critérios. WHERE docType = "user" e indexará apenas os documentos remanescentes que contêm um nome de usuário propriedade.
Dica 3: Todo índice deve ser filtrado, ou seja, deve conter uma cláusula WHERE
As indexações filtradas, muitas vezes referidas como “Indexações Parciais”, são um tipo de indexação que se aplica a um subconjunto de documentos no espaço de chave que são relevantes para a consulta em execução. O resultado é uma indexação mais pequena, o que resulta em verificações mais rápidas e tempos de resposta mais rápidos.
CREATE INDEX idx_cx3 ON `travel-sample` (estado, cidade, nome.apud) WHERE tipo = 'hotel'
CREATE INDEX idx_cx4 ON customer (state, city, name.lastname) WHERE type = 'hotel' and country = 'United States' AND ratings > 2
Dica 4: Ordem das chaves do índice e tipos de predicados
A ordem dos chaves de índice, bem como a cardinalidade (unicidade) dos valores para uma determinada chave/expressão, pode afetar drasticamente o desempenho da consulta. As chaves de índice devem ser ordenadas primeiro com base nos tipos de predicado da consulta, na ordem seguinte:
- EQUIDADE
- IN
- MENOS DO QUE
- ENTRE
- MAIOR QUE
- Predicados de matrizes
- Considere adicionar campos adicionais ao índice para abranger a consulta
Para chaves que compartilham o mesmo tipo de predicado, a cardinalidade entra em jogo. Como regra geral, ordene as chaves de forma descendente, de maior cardinalidade (mais exclusivo) para menor cardinalidade (menos exclusivo), quando elas compartilham o mesmo tipo de predicado. Note que os predicados da consulta não precisam estar listados na ordem em que estão listados no índice; o planejador de consultas determina isso automaticamente.
Considere a seguinte consulta e índice:
SELECT cid, endereço
DE DOENTE
WHERE type = 'premium'
AND state = 'CA'
E CEP nas localidades [29482, 29284, 29482, 28472]
E salário 45 anos
CREATE INDEX idx_orders ON customer(state, zipcode, salary, age, address, cid)
WHERE type = 'premium'
Apesar de zipcode é mais único do que estado, está sendo consultado usando um IN uma declaração que equivale a uma OU. É mais eficiente reduzir as entradas do índice primeiro, fazendo o seguinte: estado então por zipcode, No entanto, se nosso padrão de acesso primário fosse zipcode = 29482, Então, gostaríamos de listá-lo primeiro.
Dica 5: Índice para evitar a classificação
Cada índice armazena dados pré-classificados por meio das chaves do índice, sendo que a correspondência com as chaves na ordem BY e as N chaves iniciais evita a necessidade de classificação. Ao utilizar essa estratégia, ordem de indexação, No caso de um índice, as chaves devem ser adicionadas após todos os predicados e antes de quaisquer valores adicionais que possam ser usados para compor a consulta.
Vamos considerar um cenário em que você deseja recuperar o histórico de pedidos de um determinado usuário, considerando o seguinte índice e consulta:
CREATE INDEX `idx_order_history` ON `ecommerce`(
userId, orderDate, orderTotal, orderId
)
WHERE docType = "order"
SELECT ID da ordem, Data da ordem, Valor da ordem
DE E-COMMERCE
WHERE docType = "order" AND userId = 123
ORDEM POR data_de_pedido DESC
Se você examinar o Explique No final da página você verá um plano para a consulta:
{
"#operator": "Order",
"sort_terms": [
{
"desc": true,
"expr": "cover ((`ecommerce`.`orderDate`))"
}
]
}
O operador Order pega todos os documentos do operador anterior (IndexScan) e deve percorrer todos os registros e ordená-los em memória com base no ORDEM POR declaração. Os dados são pré-classificados ASC por padrão, com o índice anterior ASC é implícito, mas seria parecido com:
CREATE INDEX `idx_order_history2` ON `ecommerce`(userId ASC, orderDate ASC, orderTotal ASC, orderId ASC)
WHERE docType = "order"
Sabendo que queremos que o nosso resultado seja ordenado por orderDate DESC, Com isso, podemos informar o indexador a armazenar os dados na ordem em que os vamos usar:
CREATE INDEX `idx_order_history_sorted` ON `ecommerce` (userId, orderDate DESC, orderTotal, orderId)
WHERE docType = "order"
Agora, se emitirmos um Explique Na consulta, você verá que o operador “Order” está faltando, pois ele não é necessário, já que o resultado já está na ordem apropriada.
Dica 6: Use índices de cobertura
Os índices abrangentes são índices que contêm todos os predicados da consulta (ONDE), todos os valores retornados (SELECT ...) e quaisquer outros atributos processados. Quando o índice contém todos esses valores, ele “abrange” a consulta e o serviço de Consulta não precisa acessar o serviço de Dados para obter valores para esses campos. Os índices abrangentes tornam as consultas mais eficientes, pois dispensam a operação “FETCH” do serviço de Dados, economizando uma quantidade significativa de transferência de dados e processamento. Tanto o Projeto Final quanto o Filtro podem ser “abrangidos” se um índice for criado de forma adequada.
Considere o seguinte índice:
CREATE INDEX idx_cx3 ON customer(state, city, name.lastname)
O status WHERE = 'premium'
O diagrama abaixo ilustra o fluxo de execução de uma consulta que não está “coberta”:
SELECT *
DE DOENTE
WHERE state = 'CA' AND status = 'premium'

Ao executar uma SELECT *, um serviço de obtenção de dados será sempre necessário e a consulta não poderá ser abrangida.
O diagrama abaixo ilustra o fluxo de execução da consulta, onde a consulta é abordada:
Status da seleção, estado, cidade
DE DOENTE
WHERE state = 'CA' AND status = 'premium'

Como você pode ver no segundo diagrama, uma consulta bem projetada que utiliza um índice coberto evita as etapas adicionais para obter os dados do serviço de dados. Isso resulta em uma melhoria significativa no desempenho.
Podemos verificar que uma consulta está “coberta” ao revisarmos o Explique o plano:
{
...
"~children": [
{
"#operator": "IndexScan3",
"covers": [
"cover ((`customer`.`state`))",
"cover ((`customer`.`city`))",
"cover (((`customer`.`name`).`lastname`))",
"cover ((meta(`customer`).`id`))"
],
"filter_covers": {
"cover ((`customer`.`status`))": "premium"
},
...
}
]
}
É importante notar que uma operação de “FETCH” nem sempre é algo ruim e que nem todas as consultas precisam ser “cobertas”. As indexações de cobertura oferecem o benefício de ter todos os dados em um único local e evitar a necessidade de realizar operações de fetch, mas uma indexação de cobertura pode ser bastante grande e deve ser dimensionada adequadamente. Uma consulta que executa uma IndexScan e retorna alguns registros, mas depois realiza uma fetch, pode ser perfeitamente aceitável e atender aos SLAs. No entanto, uma consulta que retorna dezenas ou centenas de milhares de linhas e precisa realizar uma fetch pode ter um efeito dramático no desempenho do sistema.
Dica 7: Nunca crie um índice primário em produção
Ao contrário de bancos de dados relacionais, o Couchbase e o N1QL não exigem um índice primário, desde que a consulta tenha um índice secundário viável para acessar os dados.
Uma verificação de índice primário é semelhante a uma verificação de tabela completa em sistemas de banco de dados relacionais. No entanto, onde uma verificação de tabela pára no “table”, uma verificação de índice primário realiza o equivalente a uma verificação de tabela completa. O N1QL recupera todos os IDs de documento no conjunto de chaves inteiro a partir do índice primário, depois pega cada documento no bucket e, finalmente, executa qualquer processamento de joint-project com predicados.
Quando um índice primário existe, mesmo que nunca tenha sido “intencionado” para ser usado, ele serve como recurso de replicação para qualquer consulta que não tenha um índice satisfatório no momento da execução. Pense em cenários de falha: se as consultas que utilizam o índice (s) primário (s) ficarem indisponíveis por qualquer motivo (por exemplo, falha no nó), o índice primário será usado, o que pode causar efeitos colaterais não intencionais e inesperados.
Dica 8: Evite o uso do atributo “docType” somente no índice
Um keyspace (bucket) no Couchbase é um namespace lógico para um ou mais tipos de documentos. A prática padrão no Couchbase é garantir que cada documento tenha um identificador comum. docType, tipo, _class, etc. Propriedade que identifica o modelo/finalidade do documento. Esta propriedade não é apenas uma boa prática, pois permite uma indexação eficiente (ou seja, Índice Parcial).
Ao filtrar no docType é fortemente recomendado, pois cria um índice parcial sobre um subconjunto de documentos, criando um índice sobre o conjunto completo. docType Como índice principal ou isolado, a chave é ineficiente e possui uma cardinalidade extremamente baixa.
CREATE INDEX `idx_docType` ON `bucket` (`docType`)
Índices como este podem causar, inadvertidamente, consultas de desempenho lento e planos de explanação inesperados. Por exemplo, aumentam a probabilidade de um IntersectScan. No entanto, o mais importante é que, se você tiver implementado o uso de um docType Na maioria dos casos, os desenvolvedores que escrevem declarações N1QL adicionam isso como predicado a cada uma das suas consultas, ou seja:
SELECT *
A partir do bucket
WHERE docType = "user" AND username = "johnsmith32"
Assim como um índice primário pode ser inadvertidamente usado como recurso de emergência quando os índices esperados não são encontrados e pode causar um número potencialmente elevado de operações “FETCH”, um docType O índice pode fazer exatamente a mesma coisa e é por isso que ele deve ser evitado.
Dica 9: Índices de Partição
Quando um índice é criado, todo o índice existe apenas em um único nó (excluindo as cópias). Se o tamanho do índice crescer e ele não puder mais ser armazenado na memória no caso de índices MOI, ou se a taxa de ocupação de memória cair muito no caso de índices Standard GSI, você terá que adicionar mais recursos ao nó ou dividir o índice.
O processo de particionamento por índice implica a distribuição de um único índice grande por vários nós de índice no cluster.
Antes do Couchbase Server 5.5, isso era conseguido criando vários índices segmentados ou parciais de tamanhos menores. A seguinte consulta é um exemplo:
SELECT userId, firstName, lastName
DE E-COMMERCE
WHERE docType = 'user' E LOWER(username) = 'johnsmith32'
A seguir está o índice inicial utilizado para indexar a consulta:
CREATE INDEX idx_users ON ecommerce(LOWER(username), userId, firstName, lastName)
WHERE docType = 'user'
Com o tempo, o índice cresce em tamanho e pode não estar funcionando como esperado; não caberá mais num único nó, etc., e será necessário dividi-lo em vários nós:
CREATE INDEX idx_users_AtoM ON ecommerce(LOWER(username), userId, firstName, lastName)
WHERE docType = 'user' E LOWER(username) >= 'a' E LOWER(username) = 'n' AND LOWER(username) < '['
COM { "nodes": ["index_host2"]}
A mesma consulta acima funciona sem alterações. Os índices podem ser segmentados de diversas maneiras. A partir do Couchbase Server 5.5+, você pode definir um único índice, a estratégia de segmentação/chaves e o número de particionamentos (16 por padrão) a serem criados, e nós gerenciamos automaticamente a distribuição em todo o cluster. Particionamento de índice Pode ser implementado especificando a cláusula [PARTITION BY].
CREATE INDEX idx_users ON ecommerce(LOWER(username), userId, firstName, lastName)
WHERE docType = 'user'
PARTIÇÃO POR HASH (LOWER(username))
COM { "num_partitions": 10 }
A partição por índice possui a vantagem da “Eliminação de Partições”, na qual o planejador de consultas entende que ONDE ... LOWER(username) = 'johnsmith32', é uma igualdade e sabe qual das 10 partições com o valor indexado reside, e irá analisar apenas essa única partição. Certifique-se de avaliar as chaves/expressões que você está usando para a partição, pois isso pode afetar as verificações.
Dica 10: Evite o uso de SELECT *
Muitos desenvolvedores ou frameworks utilizam SELECT * FROM ... muito mais simples e menos trabalho do que digitar cada propriedade individualmente SELECT id_pedido, data_pedido, total_pedido FROM .... No entanto, em geral, isso não é uma prática aconselhável, independentemente da base de dados utilizada, e, em algumas situações, pode ter sérias implicações no desempenho.
Usando SELECT * retorna todas as propriedades de cada documento. Muitas vezes, uma consulta não precisa realmente de todas as propriedades, apenas algumas selecionadas. Isso causa I/O desnecessário, resultando em um tamanho de payload maior que deve ser transferido através da rede de volta para o aplicativo, onde um tamanho de payload menor é mais eficiente.
A razão mais importante para não usar SELECT * significa que você está limitando o que o optimizador de consultas pode fazer para escolher índices mais apropriados (ou seja, um índice abrangente). Quando SELECT * É usado, independentemente do caso, 100% do tempo que uma operação “FETCH” será realizada e é impossível otimizar ainda mais a consulta sem alterar o código subjacente ou a declaração N1QL.
Considere o seguinte cenário: você deseja recuperar todas as companhias aéreas de um determinado país e usar o id, nome e callsign proprietários. Inicialmente, nosso índice poderia se parecer com:
CREATE INDEX `idx_airline_country` ON `travel-sample` (country)
WHERE type = 'airline'
Agora compare as seguintes consultas:
SELECT *
A partir de `travel-sample`
WHERE type = 'airline' AND country = 'United States'
SELECT id, nome, callsign
A partir de `travel-sample`
WHERE type = 'airline' AND country = 'United States'
Ambas as consultas conseguem, no final, o resultado e, com base no nosso índice inicial, ambas as consultas executariam uma operação de “FETCH”, devido ao * na primeira consulta, e porque a segunda consulta contém propriedades que não estão no índice. Imaginemos que essa consulta seja executada 10 vezes por segundo; então, o índice pode estar perfeitamente bom e atender aos SLAs.
Você possui um monitoramento e um perfilamento adequados. Com o tempo, nosso aplicativo se torna cada vez mais popular e nossa consulta agora é realizada 1.000 vezes por segundo. Inicialmente, ambas as consultas retornavam 127 registros e uma “FETCH” estava sendo realizada onde 127 documentos * 10qps = 1.270 operações por segundo, Mas agora é diferente 127 documentos * 1000qps = 127.000 operações por segundo. Isso está causando problemas de desempenho do sistema e você percebe que é necessário fazer melhorias e que a consulta precisa de um índice coberto; o perfil da segunda consulta mostra exatamente quais campos precisam ser cobertos e você cria o seguinte índice em produção:
CREATE INDEX `idx_airline_country_cvr` ON `travel-sample` (country, id, name, callsign)
WHERE type = 'airline'
Se você estivesse usando a segunda consulta, o número de acessos por segundo aumentaria de 127,000 para 0 e você conseguiu alcançar isso sem nenhuma alteração no código ou implantação na aplicação. No entanto, se você estivesse usando a primeira consulta, esse índice não teria proporcionado nenhum benefício de desempenho; o código da aplicação teria de ser atualizado e então implantado para ver os ganhos de desempenho.
Dica 11: Evite o uso do comando USE INDEX
Quando especificado o ÍNDICE DE UTILIZAÇÃO cláusula Sugestões ao otimizador de consultas, que deve preferir o(s) índice(s) listados. O otimizador de consultas é um otimizador baseado em regras e geralmente seleciona o índice mais adequado para satisfazer uma consulta. Além disso, com cada lançamento do Couchbase, são feitas melhorias no otimizador, tornando-o mais eficiente.
Se um USO DO ÍNDICE(...) Especifica que o índice deve combinar código e operações. Ou seja, o índice especificado não pode ser removido sem uma alteração no código, pois o código espera que o índice esteja presente e, caso contrário, isso resultaria em um erro. Além disso, você não pode otimizar o índice que é utilizado sem primeiro removê-lo, o que resultaria em um período de inatividade enquanto o índice estiver sendo criado e a criação de um índice mais otimizado não traria nenhum benefício, pois isso não seria preferido.
O uso do Usar a função INDEX() A declaração pode ser benéfica na eliminação dos IntersectScans, mas deve ser feita com cautela pelos motivos listados acima.
O
USO DO ÍNDICE(...)A cláusula pode aceitar uma lista de índices delimitada por vírgulas.
Dica 12: Paginação pushdown no índice
O otimizamento das consultas de paginação é geralmente a parte mais crítica do processo de tuning. Explorar a ordem dos índices é ainda mais benéfico quando se está fazendo paginação. Tanto o OFFSET quanto o LIMIT são tentados ser deslocados para o índice sempre que possível, dependendo de alguns fatores diferentes:
- Se o predicado inteiro (
ONDE) pode ser empurrado para um único índice (ou seja, todas as chaves do índice existem) - Não está sendo realizada uma IntersectScan
- Se um
ORDEM PORSe a cláusula for utilizada, as chaves de índice devem estar na mesma ordem. - Não há
Junte-secláusula
Se todos estes forem verdadeiro então o LIMITE e OFFSET eles são enviados ao indexador; caso contrário, são aplicados pelo serviço de consulta após todas as IndexScans terem sido realizadas. Vamos considerar o seguinte índice como exemplo:
CREATE INDEX idx_products ON ecommerce ( productCategory, productName, productPrice, productId )
WHERE docType = 'produto'
Esta consulta recupera todos os produtos classificados de acordo com a Produto propriedade e explora a ordem do índice, portanto LIMITE e OFFSET São empurradas para o indexador.
SELECT productId, productName, productPrice
DE E-COMMERCE
WHERE docType = 'produto' E productCategory = "Eletrodomésticos"
ORDENAR POR PRODUCTNAME ASC
Limite 100
OFFSET 300
Isso pode ser verificado examinando o Explique plano da consulta, no IndexScan3 #O operador mostrará tanto as propriedades “limit” quanto “offset”, indicando que elas foram empurradas para o índice.
{
"#operator": "IndexScan3",
...
"index": "idx_products",
"limit": "100",
"offset": "300",
...
}
Agora, se ajustarmos a consulta para ordenar por ProdutoPreço DESC.
SELECT productId, productName, productPrice
DE E-COMMERCE
WHERE docType = 'produto' E productCategory = "Eletrodomésticos"
ORDENAR POR preço do produto DESC
Limite 100
OFFSET 300
A consulta ainda é abrangida, como antes, mas agora o parâmetro “Limite” e o “Offset” são apresentados no final da sequência e são os últimos a ocorrer antes da projeção final:
[
...
{
"#operator": "Order",
"limit": "100",
"offset": "300",
"sort_terms": [{
"desc": true,
"expr": "cover ((`ecommerce`.`productPrice`))"
}]
}, {
"#operator": "Offset",
"expr": "300"
}, {
"#operator": "Limit",
"expr": "100"
}
]
LIMITE e OFFSET Esses recursos geralmente são utilizados para a padronização de dados e o Couchbase Server possui muitas otimizações que tornam essas operações muito rápidas. Há um inconveniente com a padronização de limite/offset em qualquer banco de dados: quanto maior o offset, maior o tempo que o índice inicial tem para percorrer o índice antes que o limite seja aplicado. Muitas vezes isso é insignificante, no entanto, se você quiser tirar o máximo de desempenho da padronização, existe outra abordagem chamada KeySet Pagination.
Dica 13: Use vinculações de consulta
É responsabilidade do aplicativo limpar e verificar os dados dinâmicos/de entrada antes de enviá-los para o banco de dados. Se um aplicativo usar esses dados para construir dinamicamente uma consulta, ele estará abrindo o banco de dados para Atacados de injeção de SQL.
def airports_in_city(city):
query_string = "SELECT airportname FROM `travel-sample` WHERE city="
query_string += '"' + city + '"'
retorne cb.n1ql_query(query_string)
Isso é inseguro, pois qualquer valor ou declaração N1QL pode ser passada como Cidade. O .N1QL permite o uso de Marcadores de posição para declarar parâmetros de consulta dinâmicos. Os parâmetros de consulta (nomeados ou posicionais) permitem que o seu aplicativo utilize de forma segura argumentos dinâmicos de consulta para o seu aplicativo.
Implemente parâmetros nomeados ou posicionais para todos os argumentos de consulta dinâmicos.
def airports_in_city(city):
query_string = "SELECT airportname FROM `travel-sample` WHERE city=$1"
query = N1QLQuery(query_string, city)
retorne cb.n1ql_query(query)
Isso não só é mais seguro, como também simplifica o perfilamento e a otimização de consultas; além disso, ao emitir a mesma declaração com diferentes parâmetros, ela pode ser perfilada da mesma forma.
Dica 14: Combine índices com chaves de índice compartilhadas ou comuns
É fácil se acostumar a otimizar cada consulta e ter uma proporção de 1:1 para a indexação da mesma. Isso não é necessário e pode ser evitado, sendo necessário esperar que as chaves principais comuns de diversos índices sejam usadas e combinar vários índices em um único índice que possa atender várias consultas. Veja os seguintes exemplos:
SELECT ID da ordem, Data da ordem, Valor da ordem
DE E-COMMERCE
WHERE docType = 'ordens'
E a factura.country = 'US'
CREATE INDEX idx_orders_country ON ecommerce (billing.country)
WHERE docType = 'ordens'
SELECT ID da ordem, Data da ordem, Valor da ordem
DE E-COMMERCE
WHERE docType = 'ordens'
E a factura.country = 'US'
E billing.state = 'CA'
CREATE INDEX idx_orders_state_country ON ecommerce (
billing.state, billing.country
)
WHERE docType = 'ordens'
SELECT ID da ordem, Data da ordem, Valor da ordem
DE E-COMMERCE
WHERE docType = 'ordens'
E a factura.country = 'US'
E billing.state = 'CA'
E a ordemTotal >= 1000
CREATE INDEX idx_orders_country ON ecommerce ( billing.state, billing.country, orderTotal )
WHERE docType = 'ordens'
Todos esses índices podem ser combinados em um único índice. É importante ressaltar neste exemplo que:, billing.country é a primeira chave do índice, pois a consulta que a utiliza espera billing.country ser o principal componente do índice, isso pode ou não ter um efeito nos SLAs e deve ser testado. billing.state tem uma cardinalidade maior do que billing.country mas pode ser insignificante.
CREATE INDEX idx_orders_country ON ecommerce ( billing.country, billing.state, orderTotal )
WHERE docType = 'order'
Dica 15: Use instruções preparadas
Quando uma declaração N1QL é enviada para o servidor, o serviço de Consulta examina e analisa a sequência de caracteres, determinando quais índices devem ser consultados e, finalmente, definindo uma consulta. Plano de consulta Para satisfazer de forma ideal essa condição. O cálculo do plano adiciona algum tempo adicional de processamento e custos operacionais à consulta.
As consultas frequentemente utilizadas podem ser preparadas de forma a que o plano calculado seja gerado apenas uma vez. As subsequentes consultas que utilizam a mesma cadeia de consultas utilizarão, em vez disso, o plano pré-gerado, o que economiza tempo e processamento do plano cada vez que forem realizadas. As consultas parametrizadas são consideradas a mesma consulta para fins de armazenamento em cache e planejamento, mesmo que os parâmetros fornecidos sejam diferentes.
Existem duas abordagens para implementar declarações preparadas; escolha a que melhor se adapta ao seu ambiente.
Declarações preparadas no SDK
Este método de declarações preparadas estabelece adhoc = falso opção para uma determinada consulta. O SDK preparará internamente a instrução e armazenará o plano em um cache interno específico para essa instância do SDK. Após a primeira preparação inicial da instrução, as chamadas subsequentes à mesma instrução passarão o plano preparado para o serviço de Consulta, eliminando as etapas de inspeção, análise e planejamento e iniciando a execução imediatamente.
query = N1QLQuery("SELECT airportname FROM `travel-sample` WHERE country=$1", "USA")
q.adhoc = False
Designação de instruções preparadas
Este método de declarações preparadas é semelhante à opção anterior, mas em vez do SDK gerenciar a programação das consultas, ela seria gerenciada pelo aplicativo ou por meio de um processo externo.
Primeiro, a consulta precisa ser preparada usando um Declaração PREPARE
PREPARE unique_name_for_query FROM
SELECT airportname FROM `travel-sample` WHERE country=$1
Depois que a consulta tiver sido preparada, o plano de consulta é armazenado em cache no serviço de Consulta e pode ser executado usando um comando Executar uma declaração.
query = N1QLQuery("EXECUTE unique_name_for_query", "USA")
O problema é que existe um único plano armazenado em cache que pode ser usado por muitos clientes. No entanto, o ciclo de vida do plano precisa ser mantido. Por exemplo, se o plano não existir, será apresentada uma mensagem de erro, que deve ser capturada e então a consulta deve ser preparada novamente e executada novamente.
Dica 16: Evite os IntersectScans
Um IntersectScan é quando dois ou mais índices são usados para satisfazer uma consulta. Isso resulta em duas ou mais operações separadas de IndexScan, cada uma retornando resultados qualificados (ou seja,. meta().id) e, em seguida, cruzando os dados das duas análises, retornando apenas os resultados que estão presentes em ambas. Consideremos a seguinte consulta e os índices:
SELECT *
A partir de `travel-sample`
WHERE type = "landmark" AND activity = "drink" AND country = "France"
CREATE INDEX `idx_landmark_activity` ON `travel-sample` (atividade) WHERE tipo = "landmark"
CREATE INDEX `idx_landmark_country` ON `travel-sample` (country) WHERE type = "landmark"
Se você executar essa consulta, ela será executada em cerca de 100 ms; a análise do texto do plano mostra que uma IntersectScan é realizada e uma IndexScan é executada em cada um dos índices acima. A análise nos idx_landmark_country retorna 388 resultados e a varredura em idx_landmark_activity retorna 287 resultados; ambos são passados ao operador IntersectScan, totalizando 675 registros, e depois são filtrados para 388 resultados.
{
"~children": [{
"#operator": "IntersectScan",
"#stats": {
"#itemsIn": 675,
"#itemsOut": 388,
...
},
"scans": [{
"#operator": "IndexScan3",
"#stats": {
"#itemsOut": 388,
...
},
"index": "idx_landmark_country",
},
{
"#operator": "IndexScan3",
"#stats": {
"#itemsOut": 287,
},
"index": "idx_landmark_activity",
}
]
}]
}
Alternativamente, se um índice composto for utilizado em vez disso, isso resultará em uma única operação de IndexScan e será mais eficiente. A mesma consulta usando o índice abaixo será executada em ~17ms.
CREATE INDEX `idx_landmark_activity_country` ON `travel-sample` (atividade, país)
WHERE type = "landmark"
Em geral, um índice amplo único (índice composto) que atenda aos critérios será mais eficiente do que as intersecções em múltiplos índices singulares. Considere apenas a intersecção quando o uso do predicado não for determinístico.
Dica 17: Evite as instruções LIKE
Muitas vezes precisamos encontrar correspondências parciais dentro de uma chave de índice específica e usar uma LIKE Esta é uma sintaxe útil e conveniente; no entanto, ela realiza uma verificação de intervalo, dependendo da utilização. % Pode ser uma gama inteira do índice e resultar em muito processamento adicional. Para este exemplo, vamos usar o seguinte índice e consulta base:
CREATE INDEX idx_landmark_names ON `travel-sample` (name)
WHERE type = "landmark"
SELECT nome
A partir de `travel-sample`
WHERE type = "landmark"
E nome como %Theater%''"
Tempo de execução: ~190ms
Agora vamos analisar as diversas faixas associadas a LIKE declaração:
| Declaração | Baixo | Alto | Inclusão |
|---|---|---|---|
| ‘%Theater%’ | “” | “[]” | 1 |
| ‘Teatro%’ | “Teatro” | “Theates” | 1 |
| ‘%Teatro’ | “” | “[]” | 1 |
Claramente, a segunda opção 'Teatro%' propõe a função de varredura de faixa mais eficiente, pois trata-se de um subconjunto específico do índice, em vez de todo o índice. LIKE perguntas que correspondam apenas ao lado direito oferecem algum benefício de desempenho, mas isso nem sempre é possível.
Uma característica poderosa do N1QL é que ele pode indexar elementos individuais de uma matriz, e não apenas propriedades escalares individuais. Embora nome é uma string simples, podemos usar qualquer uma das disponíveis Funções de string para converter a string em um array (SPLIT, TOKENS, SUFFIXES, etc.) Para este exemplo, vamos usar o SUFFIXES() função.
SELECT SUFIXOS RAW ("Clay Theater")
[
[
"Clay Theater",
"lay Theater",
"ay Theater",
"y Theater",
" Theater",
"Theater",
"heater",
"eater",
"ater",
"ter",
"er",
"r"
]
]
Como isso retorna todos os sufixos possíveis de uma determinada string como um array, podemos efetivamente indexar esse array e agora remover o primeiro elemento. % de nossa solicitação, que proporciona uma variação de busca mais eficiente.
CREATE INDEX idx_landmark_names_suffixes ON `travel-sample` (
DISTINCT ARRAY v
FOR v IN SUFFIXES(LOWER(nome))
FIM
)
WHERE type = 'landmark'
SELECT nome
A partir de `travel-sample`
WHERE type = "landmark"
E QUALQUER V EM SUFIXOS(LOWER(nome))
SATISFIES vs. LIKE 'teatro%'
FIM
Tempo de execução: ~17ms
Essa consulta agora é 11 vezes mais rápida do que a original. Você deve sempre considerar o tamanho do índice de um array, pois neste caso quanto maior a string, maior o tamanho do array para cada item e maior o tamanho do índice. Referências
Dica 18: Considere os índices de matriz como uma alternativa às instruções OR
Muitas vezes precisamos escrever uma consulta que possa satisfazer a expressão “este ou aquele” e retornar resultados tanto do lado esquerdo quanto do direito da expressão. OU. Vamos tomar um exemplo comum: um usuário precisa fazer login em um aplicativo usando seu “nome de usuário” OU seu “e-mail”.
SELECT userId, pwd, firstName, lastName
DE E-COMMERCE
WHERE docType = 'user'
E (
nome de usuário = 'johns'
OU
email = 'johns'
)
E começaremos com os seguintes índices:
CREATE INDEX `idx_username` ON `ecommerce`(username) WHERE docType = 'user'
CREATE INDEX `idx_email` ON `ecommerce`(email) WHERE docType = 'user'
A visualização do plano de explanação desta consulta mostra que um UnionScan é realizado usando dois processos separados IndexScan operações sobre o idx_username e idx_email. Uma abordagem simples nesse caso seria ter o aplicativo construindo duas consultas separadas e verificando o input antes de emitir a consulta; isso é trivial de validar, o que eliminaria a necessidade de uma validação manual. UnionScan e resultar em um único IndexScan. Isso pode não ser sempre possível, então, em seguida, você pode descartar os índices anteriores e tentar criar um único índice para cobrir ambos. nome de usuário e E-mail endereço:
CREATE INDEX `idx_username_email` ON `ecommerce` (username, email)
WHERE docType = 'user'
Mas a consulta falharia, porque uma UnionScan Mesmo que ainda seja tentado, trata-se apenas de duas varreduras do mesmo índice. Para que o mesmo índice seja utilizado, seria necessário reescrevê-lo da seguinte forma:
SELECT userId, pwd, firstName, lastName
DE E-COMMERCE
WHERE docType = 'user'
E (
nome de usuário = 'johns'
OU
O nome de usuário NÃO ESTÁ SENDO OLVIDADO E o e-mail = 'johns'
)
Isso também não é uma abordagem ideal. Embora possamos manter apenas um único índice, isso resulta em UnionScan e a gama no primeiro índice é explorada completamente.
Índices de matrizes São muito poderosos e proporcionam uma execução otimizada de consultas quando os elementos de uma matriz são usados; algo impossível com os bancos de dados tradicionais. Neste caso, os nossos dados não são uma matriz, mas podemos indexá-los como uma matriz criando um array funcional.
CREATE INDEX idx_username_email_arr ON `ecommerce`(
DISTINCT ARRAY v
FOR v IN [lower(username), lower(email)]
FIM
)
WHERE docType = 'user'
SELECT userId, pwd, firstName, lastName
DE E-COMMERCE
WHERE docType = 'user'
E QUALQUER v NA [BAIXA(nome_de_usuário), BAIXA(endereço_de_e-mail)]
SATISFIES v = 'johns'
FIM
O plano de explicação verifica que apenas um único DistinctScan é executada contra nosso índice. Essa consulta só espera um único resultado, mas está realizando um “FETCH” com base nos campos. userId, pwd, firstName, lastName Não estão no índice. Se quiséssemos aproveitar ao máximo o desempenho, poderíamos cobrir a consulta com o índice:
CREATE INDEX idx_username_email_arr_cvr ON `ecommerce`( ARRAY DISTINCT v
FOR v IN [LOWER(username), LOWER(email)] END,
userId, username, pwd, firstName, lastName)
WHERE docType = 'user'
Dica 19: Favorifique os predicados de igualdade em relação a intervalos
Os valores de igualdade preditivos são preferidos e mais eficientes do que as verificações de intervalo, uma vez que o intervalo é delimitado por um valor baixo e um valor alto, e o desempenho da verificação depende da largura do intervalo. Por exemplo, quase todas as aplicações funcionam com datas de alguma forma ou outra, sendo normalmente armazenadas em um dos seguintes formatos: ISO-8601 (ou seja, “2019-01-15T10:42:23Z”) ou Horário do Epoch (ou seja, “1547548943000”) formatos. Considere a seguinte consulta e índice para encontrar todas as ordens em um determinado dia:
CREATE INDEX idx_orderDate ON `ecommerce` (orderDate)
WHERE docType = "order"
SELECT ID da ordem, Data da ordem, Valor da ordem
DE E-COMMERCE
WHERE docType = "order"
E o parâmetro orderDate >= "2019-01-15T00:00:00"
E a data de pedido < "2019-01-16"
Isso resulta em uma variação de frequência:
{
"range": [
{
"high": ""2019-01-16"",
"inclusion": 1,
"low": ""2019-01-15T00:00:00""
}
]
}
No entanto, se criarmos um índice funcional, podemos usar um único predicado de igualdade, ou seja:. WHERE orderDate = "2019-01-15"
CREATE INDEX idx_orderDate_date ON `ecommerce` (SPLIT(orderDate, "T")[0])
WHERE docType = "order"
SELECT ID da ordem, Data da ordem, Valor da ordem
DE E-COMMERCE
WHERE docType = "order"
E SPLIT(orderDate, "T")[0] = "2019-01-15"
Dica 20: Implemente a replicação de índices
Índices podem (e devem) ser replicado ao longo dos nós do cluster. Isso garante:
- Alta disponibilidade (falha de um nó do serviço Index): Se um nó do serviço Index falir, o outro continua a fornecer acesso aos índices replicados.
- Alta performance: Se cópias originais e cópias duplicadas estiverem disponíveis, as solicitações recebidas são alocadas automaticamente de forma equilibrada entre elas. Isso é contrário ao serviço de dados, onde as cópias de documentos são “passivas” e as cópias indexadas são “ativas”.
Antes do Couchbase Server 5.0, a única maneira de ter índices “replicados” era ter a mesma definição de índice, mas com um nome diferente e colocar manualmente os índices em hosts diferentes.
CREATE INDEX productName_index1 ON bucket_name(productName, ProductID)
WHERE tipo="produto"
COM { "nodes": ["host1"] }
CREATE INDEX productName_index2 ON bucket_name(productName, ProductID)
WHERE tipo="produto"
COM { "nodes": ["host2"] }
Como as réplicas de índice do Couchbase Server 5.0+ são especificadas usando o COM cláusula, basta especificar o num_replica valor.
CREATE INDEX productName_index1 ON bucket_name(productName, ProductID)
WHERE tipo="produto"
COM { "num_replica": 2 };
O único requisito é que o número de nós no cluster que executa o serviço Index seja maior ou igual a {num_replica} + 1. As réplicas também podem ser criadas especificando os nós de destino do índice:
CREATE INDEX productName_index1 ON bucket_name(productName, ProductID)
WHERE tipo="produto"
COM { "nodes": ["node1:8091", "node2:8091", "node3:8091"] }
Além disso, ambos num_replica e nodos pode ser especificado desde que num_replica é igual à distância entre nodos array + 1.
CREATE INDEX productName_index1 ON bucket_name(productName, ProductID)
WHERE tipo="produto"
COM { "num_replica": 2, "nodes": ["node1:8091", "node2:8091", "node3:8091"] }
Sempre que um Criar índice após a declaração ser emitida, o número padrão de réplicas de índice a serem criadas é 0. Este valor pode ser alterado, de forma que sempre que um Criar índice Se não houver necessidade de especificar a cláusula WITH, serão criadas automaticamente réplicas.
curl
-u Administrador:senha
-d "{"indexer.settings.num_replica": 2 }"
http://localhost:9102/settings
Dica 21: O Defer Index Builds permite compartilhar o fluxo DCP
Quando um Criar índice Após a emissão da declaração, cada documento na chave espacial deve ser projetado em relação ao índice e, por padrão, esta é uma operação síncrona. Ou seja, ela bloqueará até que o índice seja construído 100%, momento em que o índice será atualizado de forma assíncrona por quaisquer futuras mutações. Isso pode ser trabalhoso e demorado, especialmente quando se trata de gerenciar muitos índices.
No Couchbase, só pode haver um processo de construção de índice em simultâneo. No entanto, isso não significa que só possa haver um índice sendo construído em simultâneo. O N1QL permite definir o índice mas adiar a sua construção até um momento posterior, isto é feito através do WITH { "defer_build": true }.
CREATE INDEX `def_sourceairport` ON `travel-sample`(`sourceairport`)
COM { "defer_build":true }
CREATE INDEX `def_city_state` ON `travel-sample`(`city`, `state`)
COM { "defer_build":true }
Os índices estão em estado de “Criado” e não são aptos para serem usados até que sejam construídos. Para criar vários índices ao mesmo tempo, use a opção "Criar vários índices simultaneamente". Criar índice é usado.
CRIAR INÍCIO DE SÍNTESE PARA `travel-sample` (def_sourceairport, def_city_state)
O Criar índice é assíncrono por padrão e possui o principal benefício de permitir que cada construção de índice compartilhe o mesmo fluxo DCP e que cada documento projetado para a construção de índice só tenha que ser recuperado uma vez, em vez de uma vez por índice.
Dica 22: Considere a selectividade de projeção do índice
O serviço de Dados, Índice e Consulta trabalha em conjunto para executar consultas N1QL e gerenciar índices. Enquanto a maior parte do processamento de índices é realizada pelo Serviço de índice, existem dois componentes de indexação que realmente residem no Data Service. São os processos “Projector” e “Router”, responsáveis por projetar cada mutação de dados em cada índice no bucket e comunicar essas mutações ao processo “Supervisor” no Data Service.

Isto corresponde aproximadamente à quantidade # de documentos que poderiam ser incluídos no índice, dividida pelo total # de documentos no bucket.
Por exemplo, um balde com 1,000,000 documentos, e 100 Destes documentos, havia “config” documentos; se criássemos um índice com o predicado WHERE docType = "config" A selectividade de projeção é 0,10%. Por outro lado, se você criou um índice apenas docType por exemplo, e cada documento no bucket possui docType A projeção selecionável é de 100%.
Ambos estão no extremo do espectro; o primeiro satisfará apenas 0,10% das projeções, e haverá muitos ciclos de CPU desperdiçados com projeções desnecessárias; você pode considerar um padrão de acesso alternativo. Além disso, ter uma selectividade de projeção de 100% também não é eficiente, pois cada mutação corresponde à projeção e resulta em uma atualização do índice. Não há um número definido, pois isso dependerá do conjunto de dados, mas entenda as implicações de uma projeção desnecessária.
Dica 23: Combinei várias análises usando CASE Expressões
Muitas vezes, é necessário calcular diferentes agregados em diversos conjuntos de documentos. Normalmente, você consegue alcançar esse objetivo com várias digitalizações dos dados, mas é fácil calcular todos os agregados com uma única digitalização. Eliminar n-1 digitalizações pode melhorar significativamente o desempenho.
Você pode combinar várias digitalizações em uma só digitalização movendo a ONDE Cada consulta é condicionada por uma expressão CASE, que filtra os dados para a agregação. Para cada agregação, pode haver outro campo que retorne os dados.
O exemplo a seguir solicita os hotéis que oferecem acesso à internet gratuito, café da manhã gratuito ou estacionamento gratuito. Você pode obter esse resultado executando três consultas separadas:
SELECT COUNT(*) FROM `travel-sample` WHERE type="hotel" and free_internet=true
SELECT COUNT(*) FROM `travel-sample` WHERE type="hotel" and free_breakfast=true
SELECT COUNT(*) FROM `travel-sample` WHERE type="hotel" and free_parking=true
Tempo total = 119,23 + 121,63 + 118,71 = 359,57ms
No entanto, é mais eficiente executar toda a consulta em uma única declaração. Cada número é calculado como um campo. O cálculo do número utiliza um filtro com o CASE expressão para contar apenas as linhas onde a condição for válida. Por exemplo:
SELECT COUNT(CASE WHEN free_internet=true THEN 1 ELSE null END) cnt_free_internet, COUNT(CASE WHEN free_breakfast=true THEN 1 ELSE null END) cnt_free_breakfast, COUNT(CASE WHEN free_parking=true THEN 1 ELSE null END) cnt_free_parking FROM `travel-sample`
WHERE tipo="hotel"
A consulta leva 250 ms, reduzindo em 100 ms a duração total, sem falar nas chamadas à rede, processamento etc. que seriam necessárias para consultar a informação a partir do lado do aplicativo.
This is a very simple example, larger datasets will show larger variances. There could be ranges involved, the aggregation functions could be different, etc.
Tip 24: Make your Documents Index Friendly
Different access paths can determine the optimum structure of your documents. When you are leveraging N1QL, you will want to ensure your documents are “index friendly”. Ensure all documents have a consistent docType (or equivalent) attribute. This allows for efficient filtering during indexing, querying or both.
{
"docType": "user",
...
}
If you’re performing some processing on an array in the document, instead of performing that processing in the query consider storing a pre-computed value in another attribute (e.g. total, average, score, etc.)
{
...
"scores": [
78,
97,
23,
...,
43
],
"scoreTotal": 2392,
"scoreAvg": 77.6,
"scoreMin": 23,
"scoreMax": 99
}
If an attribute name is dynamic or unknown, it’s OK for KV access but not practical from an indexing standpoint. Below the first example is simply not practical to index or search if that object had every single language listed in there, you would need one index per language.
Bad for Index/Querying:
{
"Greetings": {
"English": "Good Morning",
"Spanish": "Buenos días",
"German": "Guten Morgen",
"French": "Bonjour"
}
}
Good for Index/Querying:
{
"Greetings": [
{
"Language": "English",
"Greeting": "Good Morning"
},
{
"Language": "Spanish",
"Greeting": "Buenos días"
},
{
"Language": "German",
"Greeting": "Guten Morgen"
},
{
"Language": "French",
"Greeting": "Bonjour"
}
]
}
Tip 25: USE INFER to understand your dataset
Couchbase buckets are a logical namespace made up of one or more types of documents/models. Understanding these models and their underlying structures can provide additional opportunities for performance and tuning. N1QL supports the INFER statement, that is statistical in nature. It analyzes a bucket through sampling and returns results in JSON Schema format.
INFER `travel-sample` WITH {
"sample_size": 1000,
"num_sample_values": 5,
"similarity_metric": 0.6
}
For each identified attribute, the statement returns the following details:
| Attribute | Description |
|---|---|
| #docs | Specifies the number of documents in the sample that contain this attribute. |
| %docs | Specifies the percentage of documents in the sample that contain this attribute. |
| minitems | If the data type is an array, specifies the minimum number of elements (array size). |
| maxitems | If the data type is an array, specifies the maximum number of elements (array size). |
| samples | Displays a list of sample values for the attribute found in the sample population. |
| tipo | Specifies the identified data type of the attribute. |
Tip 26: META() properties such as CAS and Expiration can be Indexed
CAS or Compare-and-Swap values are used as a form of optimistic locking for document mutations. The CAS value can be returned from a N1QL query by calling the META() function and referencing the META().cas valor.
If you are leveraging CAS operations and attempting to cover your queries, this value will need to be added to the index.
Tip 27: Beware of the Scan Consistency Level
N1QL indexes are updated asynchronously after a mutation has occurred on the data service. While key-value operations against the data service are strongly consistent, and while index updates are extremely fast (usually <1ms), because of the asynchronous nature they are “eventually consistent”.
N1QL allows you to specify the Scan Consistency level to use for a query. There are three possible values:
- Not Bounded: Is the default and the fastest. It says to return the results that are currently in the index, regardless or not if there are items in the queue waiting to be indexed.
- Request Plus: Is the opposite and slowest of the scan levels. At query time it will wait for all indexes to catch up to their highest sequence numbers. The benefit of this slower scan level is it allows you to Read Your Own Write (RYOW) but could take some time if the system is under heavy write load.
- Statement Plus / At Plus: Is unique compared to the other two scan levels and requires
mutationTokensto be enabled before it can be used. This causes a few extra bytes of information to be sent back to the SDK whenever a mutation occurs. The mutation tokens are then passed to the N1QL query and the query will wait for at least those tokens to be indexed prior to proceeding.
// enable mutation tokens
CouchbaseEnvironment env = DefaultCouchbaseEnvironment
.builder()
.mutationTokensEnabled(true)
.build();
// mutate a document and save the mutation
JsonDocument written = bucket.upsert(JsonDocument.create("mydoc", JsonObject.empty()));
// written.mutationToken() ==
// "mt{vbID=55, vbUUID=166779084590420, seqno=488, bucket=travel-sample}"
// pass the mutation to the query
bucket.query(
N1qlQuery.simple("select count(*) as cnt from `travel-sample`",
N1qlParams.build().consistentWith(written))
);
There is a price to pay for using a query scan consistency such as Request+ or Statement+. See if you can achieve the desired result by key-value Access, especially if it’s a single document or a handful of documents which can be obtained via a multi-get.
Tip 28: Use IN instead of WITHIN
O IN operator specifies the search depth to only include the current-level of the array on which it is operating against. Whereas the WITHIN operator specifies the search depth to include the current level of the array it’s operating on and tudo of the children and descendant arrays indefinitely.
The use of WITHIN can have unexpected performance consequences if used incorrectly, by recursively iterating through all arrays of a given property.
Tip 29: Cancel Long Running or Problematic Requests
Active N1QL requests are stored in the system:active_requests catalog, if the result of the query is greater than 1s it will be stored in the system:completed_requests catalog, otherwise it is discarded. If you need to cancel any active requests, you can issue a DELETE statement against the system:active_requests keyspace effectively canceling the query.
DELETE
FROM system:active_request
WHERE requestId = "..."
Tip 30: Cleanup system:completed_requests
O system:completed_requests is extremely useful with identifying slow performing and resource intensive queries. As you continue to iterate through each of the queries and optimize them, you no longer want to see that same query in system:completed_requests. You can delete records from the system:completed_requests catalog, just as you would with any other keyspace.
DELETE
FROM system:completed_requests
WHERE requestId = "..."
DELETE
FROM system:completed_requests
WHERE statement = "SELECT DISTINCT typenFROM `travel-sample`"
Tip 31: Initially Design Queries / Indexes on an Empty Bucket
Designing, building and iterating on indexes against a bucket with a large number of documents can be time-consuming. When initially designing queries and indexes, if possible, execute them against an empty bucket until you’re satisfied with the explain plan.
Tip 32: Remove Unused Indexes
Proactive monitoring is critical to any application, not only should you be actively monitoring indexes and their usage to identify potential growth needs, you should also be monitoring and identifying indexes which are not used and can be dropped.
Tip 33: Set clientContextID option in the SDK
O clientContextID is a user-defined identifier query option that can be sent to the query service from the SDK. This is not used by Couchbase for anything, however, it is stored in the system:active_requests e system:completed_requests. This can be a true application requestId/genesisId generated by the application, or some type of application identifier that can be later used for debugging or tracking down specific queries related to a given application or request.