Todos os produtos
Search
Central de documentação

Tablestore:Boolean query

Última atualização: Jul 03, 2026

Uma consulta booleana recupera linhas de uma tabela de dados ao combinar várias subconsultas. O Tablestore retorna apenas as linhas correspondentes às condições combinadas. Uma subconsulta pode ser de qualquer tipo, inclusive outra consulta booleana.

Pré-requisitos

Parâmetros

Parâmetro

Descrição

table_name

Nome da tabela de dados.

index_name

Nome do índice de pesquisa.

must_queries

Operador AND. O Tablestore retorna apenas as linhas correspondentes a todas as condições das subconsultas.

must_not_queries

Operador NOT. O Tablestore retorna apenas as linhas que não correspondem a nenhuma condição das subconsultas. Ao especificar várias subconsultas, este parâmetro equivale a NOT(A OR B): o sistema exclui a linha se ela corresponder a qualquer uma das subconsultas.

filter_queries

Filtro aplicado com lógica AND. O Tablestore retorna apenas as linhas correspondentes a todas as condições do filtro. Diferentemente de must_queries, os filtros não calculam pontuação de relevância.

should_queries

Operador OR. O Tablestore retorna as linhas correspondentes a pelo menos o número mínimo de condições das subconsultas. A pontuação de relevância de uma linha aumenta para cada condição adicional de should_queries atendida.

Use minimum_should_match para definir o número mínimo de condições obrigatórias.

minimum_should_match

Número mínimo de condições de should_queries necessárias para retornar uma linha. Se houver apenas should_queries, o valor padrão é 1. Se must_queries, must_not_queries ou filter_queries também estiver presente, o valor padrão é 0.

Exemplos

Os exemplos a seguir demonstram o uso de cada cláusula de consulta booleana. Todos chamam $otsClient->search($request) com QueryTypeConst::BOOL_QUERY como tipo de consulta.

AND

Use must_queries para exigir todas as condições. O exemplo a seguir retorna linhas em que o campo keyword é igual a "keyword" E o campo long está no intervalo [100, 101).

$request = array(
    'table_name' => 'php_sdk_test',
    'index_name' => 'php_sdk_test_search_index',
    'search_query' => array(
        'offset' => 0,
        'limit' => 2,
        'get_total_count' => true,
        'query' => array(
            'query_type' => QueryTypeConst::BOOL_QUERY,
            'query' => array(
                'must_queries' => array(
                    array(
                        'query_type' => QueryTypeConst::TERM_QUERY,
                        'query' => array(
                            'field_name' => 'keyword',
                            'term' => 'keyword'
                        )
                    ),
                    array(
                        'query_type' => QueryTypeConst::RANGE_QUERY,
                        'query' => array(
                            'field_name' => 'long',
                            'range_from' => 100,
                            'include_lower' => true,
                            'range_to' => 101,
                            'include_upper' => false
                        )
                    )
                ),
            )
        ),
        'sort' => array(
            array(
                'field_sort' => array(
                    'field_name' => 'keyword',
                    'order' => SortOrderConst::SORT_ORDER_ASC
                )
            ),
        )
    ),
    'columns_to_get' => array(
        'return_type' => ColumnReturnTypeConst::RETURN_SPECIFIED,
        'return_names' => array('keyword', 'long')
    )
);
$response = $otsClient->search($request);

OR

Use should_queries com minimum_should_match para corresponder a qualquer condição. O exemplo a seguir retorna linhas em que o campo keyword é igual a "keyword" OU o campo long está no intervalo [100, 101).

$request = array(
    'table_name' => 'php_sdk_test',
    'index_name' => 'php_sdk_test_search_index',
    'search_query' => array(
        'offset' => 0,
        'limit' => 2,
        'get_total_count' => true,
        'query' => array(
            'query_type' => QueryTypeConst::BOOL_QUERY,
            'query' => array(
                'should_queries' => array(
                    array(
                        'query_type' => QueryTypeConst::TERM_QUERY,
                        'query' => array(
                            'field_name' => 'keyword',
                            'term' => 'keyword'
                        )
                    ),
                    array(
                        'query_type' => QueryTypeConst::RANGE_QUERY,
                        'query' => array(
                            'field_name' => 'long',
                            'range_from' => 100,
                            'include_lower' => true,
                            'range_to' => 101,
                            'include_upper' => false
                        )
                    )
                ),
                'minimum_should_match' => 1
            )
        ),
        'sort' => array(
            array(
                'field_sort' => array(
                    'field_name' => 'keyword',
                    'order' => SortOrderConst::SORT_ORDER_ASC
                )
            ),
        )
    ),
    'columns_to_get' => array(
        'return_type' => ColumnReturnTypeConst::RETURN_SPECIFIED,
        'return_names' => array('keyword', 'long')
    )
);
$response = $otsClient->search($request);

NOT

Use must_not_queries para excluir linhas correspondentes a qualquer uma das condições. O exemplo a seguir exclui linhas em que o campo keyword é igual a "keyword" OU o campo long está no intervalo [100, 101), ou seja, NOT(condição A OR condição B).

$request = array(
    'table_name' => 'php_sdk_test',
    'index_name' => 'php_sdk_test_search_index',
    'search_query' => array(
        'offset' => 0,
        'limit' => 2,
        'get_total_count' => true,
        'query' => array(
            'query_type' => QueryTypeConst::BOOL_QUERY,
            'query' => array(
                'must_not_queries' => array(
                    array(
                        'query_type' => QueryTypeConst::TERM_QUERY,
                        'query' => array(
                            'field_name' => 'keyword',
                            'term' => 'keyword'
                        )
                    ),
                    array(
                        'query_type' => QueryTypeConst::RANGE_QUERY,
                        'query' => array(
                            'field_name' => 'long',
                            'range_from' => 100,
                            'include_lower' => true,
                            'range_to' => 101,
                            'include_upper' => false
                        )
                    )
                ),
            )
        ),
        'sort' => array(
            array(
                'field_sort' => array(
                    'field_name' => 'keyword',
                    'order' => SortOrderConst::SORT_ORDER_ASC
                )
            ),
        )
    ),
    'columns_to_get' => array(
        'return_type' => ColumnReturnTypeConst::RETURN_SPECIFIED,
        'return_names' => array('keyword', 'long')
    )
);
$response = $otsClient->search($request);

filter_queries

Use filter_queries quando precisar de lógica AND sem cálculo de pontuação de relevância. O exemplo a seguir retorna linhas que atendem a ambas as condições, sem pontuá-las com base na quantidade de critérios correspondidos.

$request = array(
    'table_name' => 'php_sdk_test',
    'index_name' => 'php_sdk_test_search_index',
    'search_query' => array(
        'offset' => 0,
        'limit' => 2,
        'get_total_count' => true,
        'query' => array(
            'query_type' => QueryTypeConst::BOOL_QUERY,
            'query' => array(
                'filter_queries' => array(
                    array(
                        'query_type' => QueryTypeConst::TERM_QUERY,
                        'query' => array(
                            'field_name' => 'keyword',
                            'term' => 'keyword'
                        )
                    ),
                    array(
                        'query_type' => QueryTypeConst::RANGE_QUERY,
                        'query' => array(
                            'field_name' => 'long',
                            'range_from' => 100,
                            'include_lower' => true,
                            'range_to' => 101,
                            'include_upper' => false
                        )
                    )
                ),
            )
        ),
        'sort' => array(
            array(
                'field_sort' => array(
                    'field_name' => 'keyword',
                    'order' => SortOrderConst::SORT_ORDER_ASC
                )
            ),
        )
    ),
    'columns_to_get' => array(
        'return_type' => ColumnReturnTypeConst::RETURN_SPECIFIED,
        'return_names' => array('keyword', 'long')
    )
);
$response = $otsClient->search($request);

Consultas combinadas

Aninhe consultas booleanas para criar lógicas complexas. O exemplo a seguir corresponde a linhas que satisfazem: (col2 < 4 OR col3 < 5) OR (col2 = 4 AND (col3 = 5 OR col3 = 6)).

$request = array(
    'table_name' => 'php_sdk_test',
    'index_name' => 'php_sdk_test_index',
    'search_query' => [
        'offset' => 0,
        'limit' => 10,
        'get_total_count' => false,
        'query' => [
            'query_type' => QueryTypeConst::BOOL_QUERY,
            'query' => [
                // Final combination: (col2 < 4 or col3 < 5) or (col2 = 4 and (col3 = 5 or col3 = 6)) 
                'should_queries' => [
                    [
                        'query_type' => QueryTypeConst::BOOL_QUERY,
                        'query' => [
                            // Combination 1: col2 < 4 or col3 < 5 
                            'should_queries' => [
                                [
                                    'query_type' => QueryTypeConst::RANGE_QUERY,
                                    // Condition 1: col2 < 4 
                                    'query' => [
                                        'field_name' => 'col2',
                                        'range_to' => 4
                                    ]
                                ],
                                [
                                    'query_type' => QueryTypeConst::RANGE_QUERY,
                                    // Condition 2: col3 < 5 
                                    'query' => [
                                        'field_name' => 'col3',
                                        'range_to' => 5
                                    ]
                                ]
                            ]
                        ]
                    ],
                    [
                        'query_type' => QueryTypeConst::BOOL_QUERY,
                        // Combination 2: (col2 = 4 and (col3 = 5 or col3 = 6)) 
                        'query' => [
                            'must_queries' => [
                                [
                                    'query_type' => QueryTypeConst::TERM_QUERY,
                                    // Condition 3: col2 = 4 
                                    'query' => [
                                        'field_name' => 'col2',
                                        'term' => 4
                                    ]
                                ],
                                [
                                    'query_type' => QueryTypeConst::BOOL_QUERY,
                                    // Combination 3: (col3 = 5 or col3 = 6) 
                                    'query' => [
                                        'should_queries' => [
                                            [
                                                'query_type' => QueryTypeConst::TERM_QUERY,
                                                // Condition 4: col3 = 5 
                                                'query' => [
                                                    'field_name' => 'col3',
                                                    'term' => 5
                                                ]
                                            ],
                                            [
                                                'query_type' => QueryTypeConst::TERM_QUERY,
                                                // Condition 5: col3 = 6 
                                                'query' => [
                                                    'field_name' => 'col3',
                                                    'term' => 6
                                                ]
                                            ]
                                        ],
                                        'minimum_should_match' => 1
                                    ]
                                ]
                            ]
                        ]
                    ]
                ],
                'minimum_should_match' => 1
            ]
        ]
    ],
    // You can configure the columns_to_get parameter to specify the columns to return or specify that all columns are returned. If you do not configure this parameter, only the primary key columns are returned. 
    'columns_to_get' => [ 
        //'return_type' => ColumnReturnTypeConst::RETURN_ALL // Specify that all columns are returned. 
        // Specify that the specified columns are returned. 
        'return_type' => ColumnReturnTypeConst::RETURN_SPECIFIED, 
        'return_names' => array('col1', 'col2')
    ]
);
$response = $otsClient->search($request);

Perguntas frequentes

Referências