Cómo usar la búsqueda solo por palabras clave en Knowledge Catalog

Usa la búsqueda solo por palabras clave en Knowledge Catalog para encontrar recursos con palabras clave, filtros y una sintaxis definidos. La búsqueda solo por palabras clave te brinda un control preciso sobre tus búsquedas y te permite acotar los resultados según los campos de metadatos.

Antes de comenzar

Antes de realizar la búsqueda, asegúrate de que se te hayan otorgado los roles necesarios y de haber habilitado la API necesaria.

Roles obligatorios

Para obtener los permisos que necesitas para buscar entradas y acceder a los resultados de la búsqueda en Knowledge Catalog, pídele a tu administrador que te otorgue los siguientes roles de IAM:

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Cómo usar la búsqueda solo por palabras clave

Console

Para buscar recursos con la búsqueda por palabras clave, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página Búsqueda de Knowledge Catalog.

    Ir a Búsqueda

  2. En el campo Encuentra recursos en todos los proyectos, ingresa tu consulta.

  3. Para definir mejor tu búsqueda, usa el panel Filtros. Están disponibles los siguientes filtros:

    • En Sistemas, se proporciona una lista de los sistemas disponibles, como BigQuery o Cloud SQL. El sistema de Knowledge Catalog contiene entradas personalizadas.
    • Los aspectos te permiten consultar los recursos etiquetados con una plantilla específica. Puedes usar el menú Personalizar para definir mejor los resultados y filtrar por valores de aspectos específicos.
    • En Proyecto, se enumeran los proyectos en los que puedes definir el alcance de la búsqueda.
    • Los alias de tipo son tipos de datos asociados con un tipo de entrada. Un tipo de entrada puede tener el nombre projects/test-project/locations/us/entryTypes/my-entry-type, pero puedes buscarlo con sus alias de tipo TABLE o DATABASE. Puedes establecer uno o más alias de tipo cuando creas o actualizas un tipo de entrada.
    • Los conjuntos de datos provienen de BigQuery.

    Puedes agregar manualmente los siguientes filtros:

    • Agrega un filtro de proyecto: En Proyecto, haz clic en Agregar proyecto. Busca un proyecto específico, selecciónalo y, luego, haz clic en Abrir.
    • Agrega un filtro de tipo de aspecto: En Aspectos, haz clic en el menú Agregar más tipos de aspectos. Busca una plantilla específica, selecciónala y, luego, haz clic en Aceptar.

  4. Opcional: Además de los recursos disponibles, puedes buscar recursos que estén disponibles públicamente en Google Cloud seleccionando Incluir conjuntos de datos públicos.

    Usa las siguientes sugerencias para crear una búsqueda:

    • Encierra la expresión de búsqueda entre comillas si contiene espacios. Por ejemplo, "search terms".
    • Antepone NOT a una palabra clave para que coincida con la negación lógica del filtro keyword:term. También puedes usar los operadores booleanos AND y OR para combinar expresiones de búsqueda. Los operadores AND, OR y NOT no distinguen mayúsculas de minúsculas.

    Por ejemplo, NOT column:term enumera todas las columnas, excepto las que coinciden con el término especificado.

  5. Para ver más información sobre el recurso buscado, haz clic en su nombre en los resultados de la búsqueda. Se abrirá la página de detalles de la entrada.

gcloud

Para buscar recursos, usa el comando gcloud dataplex entries search.

C#

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog C#.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

using Google.Api.Gax;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dataplex.V1;
using System;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for SearchEntries</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void SearchEntriesRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        SearchEntriesRequest request = new SearchEntriesRequest
        {
            LocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            Query = "",
            OrderBy = "",
            Scope = "",
            SemanticSearch = false,
        };
        // Make the request
        PagedEnumerable<SearchEntriesResponse, SearchEntriesResult> response = catalogServiceClient.SearchEntries(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (SearchEntriesResult item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (SearchEntriesResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (SearchEntriesResult item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<SearchEntriesResult> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (SearchEntriesResult item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Go

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Go.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewCatalogClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.SearchEntriesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#SearchEntriesRequest.
	}
	it := c.SearchEntries(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*dataplexpb.SearchEntriesResponse)
	}
}

Java

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Java.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.LocationName;
import com.google.cloud.dataplex.v1.SearchEntriesRequest;
import com.google.cloud.dataplex.v1.SearchEntriesResult;

public class SyncSearchEntries {

  public static void main(String[] args) throws Exception {
    syncSearchEntries();
  }

  public static void syncSearchEntries() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CatalogServiceClient catalogServiceClient = CatalogServiceClient.create()) {
      SearchEntriesRequest request =
          SearchEntriesRequest.newBuilder()
              .setName(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setQuery("query107944136")
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setOrderBy("orderBy-1207110587")
              .setScope("scope109264468")
              .setSemanticSearch(true)
              .build();
      for (SearchEntriesResult element : catalogServiceClient.searchEntries(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Node.js

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para Node.js.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The project to which the request should be attributed in the
 *  following form: `projects/{project}/locations/global`.
 */
// const name = 'abc123'
/**
 *  Required. The query against which entries in scope should be matched.
 *  The query syntax is defined in Search syntax for Dataplex Universal
 *  Catalog (https://cloud.google.com/dataplex/docs/search-syntax).
 */
// const query = 'abc123'
/**
 *  Optional. Number of results in the search page. If <=0, then defaults
 *  to 10. Max limit for page_size is 1000. Throws an invalid argument for
 *  page_size > 1000.
 */
// const pageSize = 1234
/**
 *  Optional. Page token received from a previous `SearchEntries` call. Provide
 *  this to retrieve the subsequent page.
 */
// const pageToken = 'abc123'
/**
 *  Optional. Specifies the ordering of results.
 *  Supported values are:
 *  * `relevance`
 *  * `last_modified_timestamp`
 *  * `last_modified_timestamp asc`
 */
// const orderBy = 'abc123'
/**
 *  Optional. The scope under which the search should be operating. It must
 *  either be `organizations/<org_id>` or `projects/<project_ref>`. If it is
 *  unspecified, it defaults to the organization where the project provided in
 *  `name` is located.
 */
// const scope = 'abc123'
/**
 *  Optional. Specifies whether the search should understand the meaning and
 *  intent behind the query, rather than just matching keywords.
 */
// const semanticSearch = true

// Imports the Dataplex library
const {CatalogServiceClient} = require('@google-cloud/dataplex').v1;

// Instantiates a client
const dataplexClient = new CatalogServiceClient();

async function callSearchEntries() {
  // Construct request
  const request = {
    name,
    query,
  };

  // Run request
  const iterable = dataplexClient.searchEntriesAsync(request);
  for await (const response of iterable) {
      console.log(response);
  }
}

callSearchEntries();

PHP

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para PHP.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\Dataplex\V1\Client\CatalogServiceClient;
use Google\Cloud\Dataplex\V1\SearchEntriesRequest;
use Google\Cloud\Dataplex\V1\SearchEntriesResult;

/**
 * Searches for Entries matching the given query and scope.
 *
 * @param string $formattedName The project to which the request should be attributed in the
 *                              following form: `projects/{project}/locations/global`. Please see
 *                              {@see CatalogServiceClient::locationName()} for help formatting this field.
 * @param string $query         The query against which entries in scope should be matched.
 *                              The query syntax is defined in [Search syntax for Dataplex Universal
 *                              Catalog](https://cloud.google.com/dataplex/docs/search-syntax).
 */
function search_entries_sample(string $formattedName, string $query): void
{
    // Create a client.
    $catalogServiceClient = new CatalogServiceClient();

    // Prepare the request message.
    $request = (new SearchEntriesRequest())
        ->setName($formattedName)
        ->setQuery($query);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $catalogServiceClient->searchEntries($request);

        /** @var SearchEntriesResult $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CatalogServiceClient::locationName('[PROJECT]', '[LOCATION]');
    $query = '[QUERY]';

    search_entries_sample($formattedName, $query);
}

Python

Python

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para Python.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_search_entries():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.SearchEntriesRequest(
        name="name_value",
        query="query_value",
    )

    # Make the request
    page_result = client.search_entries(request=request)

    # Handle the response
    for response in page_result:
        print(response)

Ruby

Ruby

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog Ruby.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

require "google/cloud/dataplex/v1"

##
# Snippet for the search_entries call in the CatalogService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::CatalogService::Client#search_entries.
#
def search_entries
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::CatalogService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::SearchEntriesRequest.new

  # Call the search_entries method.
  result = client.search_entries request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::Dataplex::V1::SearchEntriesResult.
    p item
  end
end

REST

Para buscar recursos, usa el método searchEntries.

Sintaxis de búsqueda solo de palabras clave

Para realizar búsquedas precisas, puedes crear una consulta con una sintaxis específica, incluidos calificadores, operadores lógicos y búsquedas por aspecto.

Predicados calificados

Puedes calificar un predicado anteponiéndole una clave que restrinja la coincidencia a un fragmento específico de metadatos:

  • El signo igual (=) restringe la búsqueda a una concordancia exacta.
  • Los dos puntos (:) después de la clave hacen coincidir el predicado con una subcadena o un token dentro del valor en los resultados de la búsqueda.

La tokenización divide el flujo de texto en una serie de tokens, y cada token suele corresponder a una sola palabra.

Las claves de predicado type, system, location y orgid solo admiten el calificador de coincidencia exacta (=), no el calificador de subcadena (:). Por ejemplo, type=foo o orgid=number.

La búsqueda de palabras clave de Knowledge Catalog admite los siguientes calificadores:

Calificador Descripción
name:x Coincide con x como subcadena del ID del recurso.
displayname:x Coincide con x como subcadena del nombre visible del recurso.
column:x Coincide con x como una subcadena del nombre de la columna (o del nombre de la columna anidada) en el esquema del recurso.
description:x Coincide con x como un token en la descripción del recurso.
label:bar Coincide con los recursos de BigQuery que tienen una etiqueta (con algún valor) y la clave de etiqueta tiene bar como una subcadena.
label=bar Coincide con los recursos de BigQuery que tienen una etiqueta (con algún valor) y la clave de la etiqueta es igual a bar como una cadena.
label:bar:x Coincide con x como subcadena en el valor de una etiqueta con la clave bar adjunta a un recurso de BigQuery.
label=foo:bar Coincide con los recursos de BigQuery en los que la clave es igual a foo y el valor de la clave es igual a bar.
label.foo=bar Coincide con los recursos de BigQuery en los que la clave es igual a foo y el valor de la clave es igual a bar.
label.foo Coincide con los recursos de BigQuery que tienen una etiqueta cuya clave es igual a foo como una cadena.
type=TYPE Coincide con los recursos de un tipo de entrada específico o su alias de tipo.
projectid:bar Coincide con los recursos dentro de los proyectos de Google Cloud que coinciden con bar como una subcadena en el ID.
parent:x Coincide con x como una subcadena de la ruta jerárquica de un recurso. La ruta de acceso superior es un fully_qualified_name del recurso superior.
orgid=number Coincide con los recursos dentro de una organización Google Cloud con el valor de ID exacto de number.
system=SYSTEM Coincide con los recursos de un sistema especificado.
location=LOCATION

Coincide con los recursos en una ubicación especificada con un nombre exacto. Por ejemplo, location=us-central1 coincide con los recursos alojados en Iowa.

Los recursos de BigQuery Omni admiten este calificador con el nombre de la ubicación de BigQuery Omni. Por ejemplo, location=aws-us-east-1 coincide con los recursos de BigQuery Omni en Virginia del Norte.
createtime

Busca recursos que se crearon dentro de un período determinado, antes o después de una fecha y hora específicas.

Por ejemplo:

  • createtime:2019-01-01 coincide con los recursos creados el 2019-01-01.
  • createtime<2019-02 coincide con los recursos creados antes del 2019-02-01T00:00:00.
  • createtime>2019-02 coincide con los recursos creados después del 2019-02-01T00:00:00.

Formato de marca de tiempo: YYYY-MM-DDThh:mm:ss

Todas las marcas de tiempo deben estar en GMT; no se admiten las zonas horarias. Se admiten marcas de tiempo parciales, separadores de fecha con guion (-) y separadores de fecha con barra diagonal (/).

Por ejemplo:

  • 2010-10-22T05:36:24
  • 2010-10-22T05:36
  • 2010-10-22T05
  • 2010-10-22
  • 2010-10
  • 2010
  • 2010/10/22
updatetime

Busca recursos que se actualizaron dentro de una fecha u hora determinada, antes o después de ella.

Por ejemplo:

  • updatetime:2019-01-01 coincide con los recursos actualizados el 1 de enero de 2019.
  • updatetime<2019-02 coincide con los recursos actualizados antes de 2019-02-01T00:00:00.
  • updatetime>2019-02 coincide con los recursos actualizados después del 2019-02-01T00:00:00.

Formato de marca de tiempo: YYYY-MM-DDThh:mm:ss

Todas las marcas de tiempo deben estar en GMT; no se admiten las zonas horarias. Se admiten marcas de tiempo parciales, separadores de fecha con guion (-) y separadores de fecha con barra diagonal (/).

Por ejemplo:

  • 2010-10-22T05:36:24
  • 2010-10-22T05:36
  • 2010-10-22T05
  • 2010-10-22
  • 2010-10
  • 2010
  • 2010/10/22
fully_qualified_name:x Coincide con x como una subcadena de fully_qualified_name.
fully_qualified_name=x Coincide con x como fully_qualified_name.

Para buscar entradas según sus aspectos adjuntos, usa la siguiente sintaxis de consulta.

Calificador Descripción
aspect:x Coincide con x como una subcadena de la ruta de acceso completa al tipo de aspecto de un aspecto que se adjunta a la entrada, en el formato projectid.location.ASPECT_TYPE_ID
aspect=x Coincide con x como la ruta de acceso completa al tipo de aspecto de un aspecto que se adjunta a la entrada, en el formato projectid.location.ASPECT_TYPE_ID
aspect:xOPERATORvalue

Busca valores de campos de aspectos. Coincide con x como una subcadena de la ruta de acceso completa al tipo de aspecto y el nombre del campo de un aspecto que se adjunta a la entrada, en el formato projectid.location.ASPECT_TYPE_ID.FIELD_NAME

La lista de operadores admitidos depende del tipo de campo del aspecto, como se indica a continuación:

  • Cadena: = (concordancia exacta) y : (subcadena)
  • Todos los tipos de números: =, :, <, >, <=, >=, =>, =<
  • Enum: =
  • Datetime: Igual que para los números, pero los valores que se comparan se tratan como fechas y horas en lugar de números.
  • Booleano: =

Solo se pueden buscar los campos de nivel superior del aspecto.

Por ejemplo, todas las siguientes búsquedas coinciden con las entradas en las que el valor del campo is-enrolled en el aspecto employee-info es true. También se devuelven otras entradas que coinciden con la subcadena.

  • aspect:example-project.us-central1.employee-info.is-enrolled=true
  • aspect:example-project.us-central1.employee=true
  • aspect:employee=true

Operadores lógicos

Una consulta puede constar de varios predicados vinculados con operadores lógicos AND, OR o NOT.

  • Si no especificas un operador, AND lógico está implícito. Por ejemplo, foo bar devuelve recursos que coinciden con el predicado foo y el predicado bar.
  • Niega un predicado con un prefijo - (guion) o NOT. Por ejemplo, -name:foo devuelve recursos con nombres que no coinciden con el predicado foo.

En la búsqueda solo por palabras clave, los operadores lógicos no distinguen mayúsculas de minúsculas.

Sintaxis abreviada

Para usar la sintaxis abreviada en tus consultas, usa | (barra vertical) para los operadores OR y , (coma) para los operadores AND. La sintaxis abreviada funciona para los predicados calificados, excepto para label.

En los siguientes ejemplos, se muestra cómo usar la sintaxis abreviada con la búsqueda solo por palabras clave.

  • Busca entradas dentro de uno de los muchos proyectos con el operador OR

    projectid:(id1|id2|id3|id4)

    La misma búsqueda sin usar la sintaxis abreviada se ve de la siguiente manera:

    projectid:id1 OR projectid:id2 OR projectid:id3 OR projectid:id4

  • Busca entradas con nombres de columna coincidentes:

    • AND: column:(name1,name2,name3)
    • O: column:(name1|name2|name3)

¿Qué sigue?