Esta página se ha traducido con Cloud Translation API.

Actualizar un esquema

Puede actualizar el esquema de cualquier dato que lo admita, como los datos estructurados, los datos de sitios web con datos estructurados u otros datos no estructurados con metadatos.

Puedes actualizar el esquema en la Google Cloud consola o mediante el método de la API schemas.patch. Solo se puede actualizar el esquema de un sitio web a través de la API REST.

Para actualizar el esquema, puedes añadir campos nuevos, cambiar las anotaciones indexables, de búsqueda y recuperables de un campo, o marcar un campo como propiedad clave, como title, uri y description.

Actualizar el esquema

Puedes actualizar tu esquema en la Google Cloud consola o mediante la API.

Consola

Para actualizar un esquema en la Google Cloud consola, sigue estos pasos:

Consulta la sección Requisitos y limitaciones para comprobar que la actualización del esquema sea válida.
Si vas a actualizar las anotaciones de campo (es decir, si vas a definir campos como indexables, recuperables, facetables dinámicos, aptos para búsquedas o completables), consulta las limitaciones y los requisitos de cada tipo de anotación.
Comprueba que has completado la ingestión de datos. De lo contrario, es posible que el esquema aún no esté disponible para editarse.
En la Google Cloud consola, ve a la página Aplicaciones de IA.

Aplicaciones de IA
En el menú de navegación, haga clic en Almacenes de datos.
En la columna Nombre, haga clic en el almacén de datos con el esquema que quiera actualizar.
Haga clic en la pestaña Esquema para ver el esquema de sus datos.

Esta pestaña puede estar vacía si es la primera vez que editas los campos.
Haz clic en el botón Edit (Editar).
Actualiza el esquema:
- Asignar propiedades clave: en la columna Propiedades clave de su esquema, seleccione una propiedad clave para asignar un campo. Por ejemplo, si un campo llamado details siempre contiene la descripción de un documento, asigne ese campo a la propiedad de clave Description.
- Actualizar el número de dimensiones (opción avanzada): puede actualizar este ajuste si utiliza inserciones de vectores personalizadas con Vertex AI Search. Consulta Opciones avanzadas: usar inserciones personalizadas.
- Actualizar anotaciones de campos: para actualizar las anotaciones de un campo, selecciona o deselecciona el ajuste de anotación de un campo. Las anotaciones disponibles son Retrievable, Indexable, Dynamic Facetable, Searchable y Completable. Algunos ajustes de campo tienen limitaciones. Consulte Configurar ajustes de campos para ver las descripciones y los requisitos de cada tipo de anotación.
- Añadir un campo nuevo: si añades campos nuevos a tu esquema antes de importar documentos con esos campos, las aplicaciones de IA tardarán menos en reindexar tus datos después de la importación.
  1. Haga clic en Añadir campos para desplegar esa sección.
  2. Haz clic en add_box Añadir nodo y especifica los ajustes del nuevo campo.
    
    Para indicar una matriz, selecciona Sí en Matriz. Por ejemplo, para añadir un array de cadenas, asigna el valor string a type y el valor Yes a Array.
    
    En el caso de los índices de almacén de datos de sitios web, todos los campos que añada serán matrices de forma predeterminada.
Haz clic en Guardar para aplicar los cambios en el esquema.

Si se cambia el esquema, se vuelve a indexar. En el caso de los almacenes de datos grandes, la reindexación puede tardar horas.

REST

Para usar la API y actualizar tu esquema, sigue estos pasos:

Consulta las secciones Requisitos y limitaciones y Ejemplos de limitaciones (solo REST) para comprobar que los cambios en el esquema son válidos.

Para actualizar el esquema de los almacenes de datos con sitios web o datos no estructurados con metadatos, ve al paso 5 para llamar al método schema.patch.
Si vas a actualizar las anotaciones de campo (es decir, si vas a definir campos como indexables, recuperables, facetables dinámicos o aptos para búsquedas), consulta el artículo Configurar los ajustes de los campos para conocer las limitaciones y los requisitos de cada tipo de anotación.
Si está editando un esquema detectado automáticamente, asegúrese de que ha completado la ingestión de datos. De lo contrario, es posible que el esquema aún no esté disponible para editarlo.
Busca el ID de tu almacén de datos. Si ya tiene el ID del almacén de datos, vaya al siguiente paso.
1. En la Google Cloud consola, ve a la página Aplicaciones de IA y, en el menú de navegación, haz clic en Almacenes de datos.
  
  Ir a la página Almacenes de datos
2. Haga clic en el nombre de su almacén de datos.
3. En la página Datos de su almacén de datos, obtenga el ID del almacén de datos.

Usa el método de la API schemas.patch para proporcionar tu nuevo esquema JSON como objeto JSON.

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://discoveryengine.googleapis.com/v1beta/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/schemas/default_schema" \
-d '{
  "structSchema": JSON_SCHEMA_OBJECT
}'

Haz los cambios siguientes:

PROJECT_ID: el ID de tu proyecto de Google Cloud .
DATA_STORE_ID: el ID del almacén de datos de Vertex AI Search.

JSON_SCHEMA_OBJECT: tu nuevo esquema JSON como objeto JSON. Por ejemplo:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "keyPropertyMapping": "title"
    },
    "categories": {
      "type": "array",
      "items": {
        "type": "string",
        "keyPropertyMapping": "category"
      }
    },
    "uri": {
      "type": "string",
      "keyPropertyMapping": "uri"
    }
  }
}

Ejemplo de comando y resultado

curl -X PATCH -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" "https://discoveryengine.googleapis.com/v1/projects/my-project-123/locations/global/collections/default_collection/dataStores/my-data-store/schemas/default_schema" -d '{
"structSchema": {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"properties": {
"title": {
"type": "string",
"keyPropertyMapping": "title"
},
"categories": {
"type": "array",
"items": {
"type": "string",
"keyPropertyMapping": "category"
}
},
"uri": {
"type": "string",
"keyPropertyMapping": "uri"
}
}
}
}'

{
"name": "projects/123456/locations/global/collections/default_collection/dataStores/my-data-store/schemas/default_schema/operations/update-schema-10569824819404198922",
"metadata": {
"@type": "type.googleapis.com/google.cloud.discoveryengine.v1.UpdateSchemaMetadata"
}
}

Opcional: Revisa el esquema siguiendo el procedimiento Ver una definición de esquema.

C#

Para obtener más información, consulta la documentación de referencia de la API AI Applications C#.

Para autenticarte en las aplicaciones de IA, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

using Google.Cloud.DiscoveryEngine.V1;
using Google.LongRunning;

public sealed partial class GeneratedSchemaServiceClientSnippets
{
    /// <summary>Snippet for UpdateSchema</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 UpdateSchemaRequestObject()
    {
        // Create client
        SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
        // Initialize request argument(s)
        UpdateSchemaRequest request = new UpdateSchemaRequest
        {
            Schema = new Schema(),
            AllowMissing = false,
        };
        // Make the request
        Operation<Schema, UpdateSchemaMetadata> response = schemaServiceClient.UpdateSchema(request);

        // Poll until the returned long-running operation is complete
        Operation<Schema, UpdateSchemaMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Schema result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<Schema, UpdateSchemaMetadata> retrievedResponse = schemaServiceClient.PollOnceUpdateSchema(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Schema retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Para obtener más información, consulta la documentación de referencia de la API AI Applications Go.


package main

import (
	"context"

	discoveryengine "cloud.google.com/go/discoveryengine/apiv1"
	discoveryenginepb "cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb"
)

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 := discoveryengine.NewSchemaClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &discoveryenginepb.UpdateSchemaRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb#UpdateSchemaRequest.
	}
	op, err := c.UpdateSchema(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Para obtener más información, consulta la documentación de referencia de la API AI Applications Java.

import com.google.cloud.discoveryengine.v1.Schema;
import com.google.cloud.discoveryengine.v1.SchemaServiceClient;
import com.google.cloud.discoveryengine.v1.UpdateSchemaRequest;

public class SyncUpdateSchema {

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

  public static void syncUpdateSchema() 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 (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {
      UpdateSchemaRequest request =
          UpdateSchemaRequest.newBuilder()
              .setSchema(Schema.newBuilder().build())
              .setAllowMissing(true)
              .build();
      Schema response = schemaServiceClient.updateSchemaAsync(request).get();
    }
  }
}

Python

Para obtener más información, consulta la documentación de referencia de la API AI Applications Python.

# 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 discoveryengine_v1


def sample_update_schema():
    # Create a client
    client = discoveryengine_v1.SchemaServiceClient()

    # Initialize request argument(s)
    request = discoveryengine_v1.UpdateSchemaRequest(
    )

    # Make the request
    operation = client.update_schema(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

Para obtener más información, consulta la documentación de referencia de la API AI Applications Ruby.

require "google/cloud/discovery_engine/v1"

##
# Snippet for the update_schema call in the SchemaService 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::DiscoveryEngine::V1::SchemaService::Client#update_schema.
#
def update_schema
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DiscoveryEngine::V1::SchemaService::Client.new

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

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Requisitos y limitaciones

Cuando actualices un esquema, asegúrate de que el nuevo esquema sea compatible con el esquema que estás actualizando. Para actualizar un esquema con un esquema nuevo que no sea retrocompatible, debes eliminar todos los documentos del almacén de datos, eliminar el esquema y crear uno nuevo.

Si actualizas un esquema, se vuelve a indexar todos los documentos. Este proceso puede llevar tiempo y generar costes adicionales:

Hora. Volver a indexar un almacén de datos de gran tamaño puede llevar horas o días.
Gasto. La reindexación puede generar costes, en función del analizador. Por ejemplo, se aplican costes a la reindexación de almacenes de datos que usan el analizador OCR o el analizador de diseño. Para obtener más información, consulta los precios de las funciones de Document AI.

Las actualizaciones de esquemas no admiten lo siguiente:

Cambiar el tipo de un campo. Una actualización del esquema no permite cambiar el tipo del campo. Por ejemplo, un campo asignado a integer no se puede cambiar a string.
Quitar un campo. Una vez definido, no se puede eliminar. Puedes seguir añadiendo campos, pero no puedes quitar ninguno.

Ejemplos de limitaciones (solo REST)

En esta sección se muestran ejemplos de tipos de actualizaciones de esquemas válidos y no válidos. En estos ejemplos se usa el siguiente esquema JSON:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "title": {
      "type": "string"
    },
    "description": {
      "type": "string",
      "keyPropertyMapping": "description"
    },
    "categories": {
      "type": "array",
      "items": {
        "type": "string",
        "keyPropertyMapping": "category"
      }
    }
  }
}

Ejemplos de actualizaciones admitidas

Se admiten las siguientes actualizaciones del esquema de ejemplo.

Añadir un campo En este ejemplo, se ha añadido el campo properties.uri al esquema.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "title": {
      "type": "string"
    },
    "description": {
      "type": "string",
      "keyPropertyMapping": "description"
    },
    "uri": { // Added field. This is supported.
      "type": "string",
      "keyPropertyMapping": "uri"
    },
    "categories": {
      "type": "array",
      "items": {
        "type": "string",
        "keyPropertyMapping": "category"
      }
    }
  }
}

Añadir o quitar anotaciones de propiedades clave de title, description o uri. En este ejemplo, se ha añadido keyPropertyMapping al campo title.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "keyPropertyMapping": "title" // Added "keyPropertyMapping". This is supported.
    },
    "description": {
      "type": "string",
      "keyPropertyMapping": "description"
    },
    "categories": {
      "type": "array",
      "items": {
        "type": "string",
        "keyPropertyMapping": "category"
      }
    }
  }
}

Ejemplos de actualizaciones de esquemas no válidas

No se admiten las siguientes actualizaciones del esquema de ejemplo.

Cambiar el tipo de un campo. En este ejemplo, el tipo del campo title ha cambiado de cadena a número. Esta opción no está disponible.

  {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "properties": {
      "title": {
        "type": "number" // Changed from string. Not allowed.
      },
      "description": {
        "type": "string",
        "keyPropertyMapping": "description"
      },
      "categories": {
        "type": "array",
        "items": {
          "type": "string",
          "keyPropertyMapping": "category"
        }
      }
    }
  }

Quitar un campo. En este ejemplo, se ha quitado el campo title. Esta opción no está disponible.

  {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "properties": {
      // "title" is removed. Not allowed.
      "description": {
        "type": "string",
        "keyPropertyMapping": "description"
      },
      "uri": {
        "type": "string",
        "keyPropertyMapping": "uri"
      },
      "categories": {
        "type": "array",
        "items": {
          "type": "string",
          "keyPropertyMapping": "category"
        }
      }
    }
  }