Usa la API de BigQuery Storage Write

La API de BigQuery Storage Write es una API de transmisión basada en gRPC para transferir datos a BigQuery con una capacidad de procesamiento alta. La API de Storage Write combina la funcionalidad de la transferencia de transmisión y la carga por lotes en una sola API. Puedes usar la API de Storage Write para transmitir registros a BigQuery que están disponibles para consultas a medida que se escriben, o para procesar por lotes una cantidad arbitraria de registros y confirmarlos en una sola operación atómica.

Ventajas de usar la API de Storage Write

Semántica de entrega exacta una vez. La API de Storage Write admite una semántica de tipo “exactamente una vez” mediante el uso de compensaciones de transmisión. A diferencia del método insertAll, la API de Storage Write nunca escribe dos mensajes que tienen la misma compensación dentro de una transmisión, si el cliente proporciona compensaciones de transmisión cuando agrega registros.

Transacciones a nivel de transmisión. Puedes escribir datos en una transmisión y confirmarlos como una sola transacción. Si la operación de confirmación falla, puedes reintentar la operación de forma segura. Por ejemplo, en una canalización de transmisión, si un trabajador falla, otro trabajador puede recoger la tarea.

Transacciones en las transmisiones. Varios trabajadores pueden crear sus propias transmisiones para procesar datos de forma independiente. Cuando todos los trabajadores finalizan, puedes confirmar todas las transmisiones como una transacción.

Protocolo eficiente. La API de Storage Write es más eficiente que el método insertAll anterior porque usa transmisión de gRPC en lugar de REST a través de HTTP. La API de Storage Write también admite formatos de objetos binarios en forma de búferes de protocolo, que son un formato de conexión más eficiente que JSON. Las solicitudes de escritura son asíncronas con orden garantizado.

Detección de actualización del esquema. Si el esquema de la tabla subyacente cambia mientras el cliente está transmitiendo, la API de Storage Write notifica al cliente. El cliente puede decidir si quiere volver a conectarse mediante el esquema actualizado o continuar escribiendo en la conexión existente.

Permisos necesarios

Para usar la API de Storage Write, debes tener los permisos bigquery.tables.updateData.

Las siguientes funciones predefinidas de Identity and Access Management (IAM) incluyen los permisos bigquery.tables.updateData:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Funciones y permisos predefinidos.

Descripción general del uso de la API de Storage Write

La API de Storage Write es compatible con dos modos:

  • Modo de confirmación. En este modo, el cliente escribe registros que están disponibles de inmediato para realizar consultas. Usa este modo para cargas de trabajo de transmisión.

  • Modo pendiente. En este modo, el cliente escribe un lote de registros, que se almacenan en búfer en estado pendiente. Una vez que el cliente termina de escribir, confirma cada transmisión pendiente. Una vez que se confirma una transmisión, los datos que se escribieron en dicha transmisión están disponibles para su lectura. La confirmación es una operación atómica. Usa este modo para las cargas de trabajo por lotes como alternativa a los trabajos de carga de BigQuery.

Para usar la API de Storage Write, puedes llamar a la API de gRPC directamente o usar la biblioteca cliente, que está disponible para Java. En general, recomendamos usar la biblioteca cliente porque proporciona una interfaz de programación más simple y administra la RPC de transmisión bidireccional subyacente para ti.

La biblioteca cliente proporciona dos objetos de escritor:

  • StreamWriterV2. El objeto StreamWriterV2 acepta datos en formato de búfer de protocolo.

  • JsonStreamWriter. El objeto JsonStreamWriter acepta datos en formato JSON y los convierte en búferes de protocolo. Si ya tienes datos en formato JSON en tu aplicación, puedes usar JsonStreamWriter para transferir los datos. El JsonStreamWriter convierte de forma automática los datos del lado del cliente al formato binario subyacente de la API de Storage Write antes de enviarlos mediante una conexión inalámbrica.

El modelo de programación es similar para ambos escritores. La diferencia principal es la forma en que le das formato a la carga útil. En las siguientes secciones, se describe cómo usar la biblioteca cliente para el modo de confirmación y el modo pendiente.

Usa la API de Storage Write con el cliente de Java

En las siguientes secciones, se describe cómo usar el cliente de Java para escribir datos en la API de Storage Write.

Escribe en una transmisión en modo de confirmación

En el modo de confirmación, los registros están disponibles para consultas tan pronto como el cliente recibe la confirmación desde el backend. El modo de confirmación proporciona una entrega de tipo "exactamente única" dentro de una transmisión mediante el uso de compensaciones de registro. La aplicación puede especificar el número de compensación para cada registro. La operación de escritura solo se realiza si el valor de compensación coincide con la siguiente compensación de anexo. Si no se proporciona ninguna compensación, los registros se agregan al final actual de la transmisión. En ese caso, si un anexo muestra un error, volver a intentar la operación podría hacer que el registro aparezca más de una vez en la transmisión.

Para escribir registros en modo de confirmación con el objeto JsonStreamWriter, realiza los siguientes pasos:

  1. Crea una instancia nueva del objeto BigQueryWriteClient.

  2. Llama a BigQueryWriteClient.createWriteStream para crear un objeto WriteStream. Para el modo, especifica WriteStream.Type.COMMITTED.

  3. Crear una instancia de JsonStreamWriter. Proporciona un esquema que sea compatible con el esquema de tabla. Puedes construir un esquema de forma manual como un objeto TableSchema o recuperar el esquema de la tabla de BigQuery.

  4. Llama a JsonStreamWriter.append y pasa un arreglo JSONArray de registros JSONObject. De manera opcional, especifica la compensación del registro en la transmisión. Si proporcionas la compensación, la API de Storage Write nunca escribe dos mensajes que tienen la misma compensación. El método append es asíncrono. Se garantiza el orden si proporcionas compensaciones.

Java

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

import com.google.api.core.ApiFuture;
import com.google.cloud.bigquery.storage.v1beta2.AppendRowsResponse;
import com.google.cloud.bigquery.storage.v1beta2.BigQueryWriteClient;
import com.google.cloud.bigquery.storage.v1beta2.CreateWriteStreamRequest;
import com.google.cloud.bigquery.storage.v1beta2.JsonStreamWriter;
import com.google.cloud.bigquery.storage.v1beta2.TableName;
import com.google.cloud.bigquery.storage.v1beta2.WriteStream;
import com.google.protobuf.Descriptors.DescriptorValidationException;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import org.json.JSONArray;
import org.json.JSONObject;

public class WriteCommittedStream {

  public static void runWriteCommittedStream()
      throws DescriptorValidationException, InterruptedException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";

    writeCommittedStream(projectId, datasetName, tableName);
  }

  public static void writeCommittedStream(String projectId, String datasetName, String tableName)
      throws DescriptorValidationException, InterruptedException, IOException {

    try (BigQueryWriteClient client = BigQueryWriteClient.create()) {
      // Initialize a write stream for the specified table.
      // For more information on WriteStream.Type, see:
      // https://googleapis.dev/java/google-cloud-bigquerystorage/latest/com/google/cloud/bigquery/storage/v1beta2/WriteStream.Type.html
      WriteStream stream = WriteStream.newBuilder().setType(WriteStream.Type.COMMITTED).build();
      TableName parentTable = TableName.of(projectId, datasetName, tableName);
      CreateWriteStreamRequest createWriteStreamRequest =
          CreateWriteStreamRequest.newBuilder()
              .setParent(parentTable.toString())
              .setWriteStream(stream)
              .build();
      WriteStream writeStream = client.createWriteStream(createWriteStreamRequest);

      // Use the JSON stream writer to send records in JSON format.
      // For more information about JsonStreamWriter, see:
      // https://googleapis.dev/java/google-cloud-bigquerystorage/latest/com/google/cloud/bigquery/storage/v1beta2/JsonStreamWriter.html
      try (JsonStreamWriter writer =
          JsonStreamWriter.newBuilder(writeStream.getName(), writeStream.getTableSchema(), client)
              .build()) {
        // Append 10 JSON objects to the stream.
        for (int i = 0; i < 10; i++) {
          // Create a JSON object that is compatible with the table schema.
          JSONObject record = new JSONObject();
          record.put("col1", String.format("record %03d", i));
          JSONArray jsonArr = new JSONArray();
          jsonArr.put(record);

          // To detect duplicate records, pass the index as the record offset.
          // To disable deduplication, omit the offset or use WriteStream.Type.DEFAULT.
          ApiFuture<AppendRowsResponse> future = writer.append(jsonArr, i);
          AppendRowsResponse response = future.get();
        }
      }
      System.out.println("Appended records successfully.");
    } catch (ExecutionException e) {
      // If the wrapped exception is a StatusRuntimeException, check the state of the operation.
      // If the state is INTERNAL, CANCELLED, or ABORTED, you can retry. For more information, see:
      // https://grpc.github.io/grpc-java/javadoc/io/grpc/StatusRuntimeException.html
      System.out.println("Failed to append records. \n" + e.toString());
    }
  }
}

El objeto StreamWriterV2 es similar al objeto JsonStreamWriter, pero el método StreamWriter.append toma un objeto AppendRowsRequest, que contiene una lista de mensajes de búfer de protocolo, en lugar de objetos JSON.

Escribe en la transmisión predeterminada

La API de Storage Write proporciona una transmisión predeterminada que agrega registros en el modo de confirmación sin garantías de solo una vez. La transmisión predeterminada puede admitir una capacidad de procesamiento mayor que la creación de una transmisión dedicada. Además, la transmisión predeterminada no está sujeta al límite de cuota en la creación de transmisiones de escritura. Cualquier cantidad de clientes puede escribir de forma simultánea en la transmisión predeterminada.

En el siguiente código, se muestra cómo usar la transmisión predeterminada con el objeto JsonStreamWriter:

Java

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

import com.google.api.core.ApiFuture;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.storage.v1beta2.AppendRowsResponse;
import com.google.cloud.bigquery.storage.v1beta2.JsonStreamWriter;
import com.google.cloud.bigquery.storage.v1beta2.TableName;
import com.google.protobuf.Descriptors.DescriptorValidationException;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import org.json.JSONArray;
import org.json.JSONObject;

public class WriteToDefaultStream {

  public static void runWriteToDefaultStream()
      throws DescriptorValidationException, InterruptedException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";

    writeToDefaultStream(projectId, datasetName, tableName);
  }

  public static void writeToDefaultStream(String projectId, String datasetName, String tableName)
      throws DescriptorValidationException, InterruptedException, IOException {
    BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
    Table table = bigquery.getTable(datasetName, tableName);
    TableName parentTable = TableName.of(projectId, datasetName, tableName);
    Schema schema = table.getDefinition().getSchema();

    // Use the JSON stream writer to send records in JSON format.
    // For more information about JsonStreamWriter, see:
    // https://googleapis.dev/java/google-cloud-bigquerystorage/latest/com/google/cloud/bigquery/storage/v1beta2/JstreamWriter.html
    try (JsonStreamWriter writer =
        JsonStreamWriter.newBuilder(parentTable.toString(), schema).build()) {
      // Append 10 JSON objects to the stream.
      for (int i = 0; i < 10; i++) {
        // Create a JSON object that is compatible with the table schema.
        JSONObject record = new JSONObject();
        record.put("col1", String.format("record %03d", i));
        JSONArray jsonArr = new JSONArray();
        jsonArr.put(record);

        ApiFuture<AppendRowsResponse> future = writer.append(jsonArr);
        AppendRowsResponse response = future.get();
      }
      System.out.println("Appended records successfully.");
    } catch (ExecutionException e) {
      // If the wrapped exception is a StatusRuntimeException, check the state of the operation.
      // If the state is INTERNAL, CANCELLED, or ABORTED, you can retry. For more information, see:
      // https://grpc.github.io/grpc-java/javadoc/io/grpc/StatusRuntimeException.html
      System.out.println("Failed to append records. \n" + e.toString());
    }
  }
}

Este código es similar al ejemplo anterior, pero en lugar de llamar a BigQueryWriteClient.createWriteStream para crear una transmisión de escritura, llama al método JsonStreamWriter.Builder.createDefaultStream.

Escribe en una transmisión en modo pendiente

El modo pendiente es útil para la carga de datos de forma masiva en lotes grandes. También es útil para cargar lotes más pequeños, lo que es un patrón común en algunas arquitecturas de procesamiento de datos.

El modo pendiente admite transacciones a nivel de transmisión. Una transmisión solo se puede confirmar una vez. Varios trabajadores pueden trabajar en la misma unidad de datos sin que se escriban dos veces los mismos datos. La confirmación se encuentra en operación atómica. Si falla, puedes volver a intentarlo.

Para usar el objeto JsonStreamWriter en modo pendiente, realiza los siguientes pasos:

  1. Crea una instancia del objeto BigQueryWriteClient.

  2. Llama a BigQueryWriteClient.createWriteStream para crear uno o más objetos WriteStream. Para el modo, especifica WriteStream.Type.PENDING.

  3. Llama a StreamWriter.append y pasa un JSONArray de los registros JSONObject. De manera opcional, si deseas la detección de mensajes duplicados, especifica la compensación del registro en la transmisión.

  4. Cuando termines de escribir una transmisión, llama a BigQueryWriteClient.finalizeWriteStream para finalizar la transmisión. Después de llamar a este método, no puedes escribir más registros en esa transmisión.

  5. Cuando se completen todas las transmisiones, llama a BigQueryWriteClient.batchCommitWriteStreams con la lista de transmisiones. Este método confirma los datos de esas transmisiones.

  6. Llama a BatchCommitWriteStreamsResponse.hasCommitTime en el objeto BatchCommitWriteStreamsResponse que se muestra. Si este método muestra false, la confirmación falló. Llama al método getStreamErrorsList para obtener la lista de errores de cada transmisión que falló.

Java

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

import com.google.api.core.ApiFuture;
import com.google.cloud.bigquery.storage.v1beta2.AppendRowsResponse;
import com.google.cloud.bigquery.storage.v1beta2.BatchCommitWriteStreamsRequest;
import com.google.cloud.bigquery.storage.v1beta2.BatchCommitWriteStreamsResponse;
import com.google.cloud.bigquery.storage.v1beta2.BigQueryWriteClient;
import com.google.cloud.bigquery.storage.v1beta2.CreateWriteStreamRequest;
import com.google.cloud.bigquery.storage.v1beta2.FinalizeWriteStreamResponse;
import com.google.cloud.bigquery.storage.v1beta2.JsonStreamWriter;
import com.google.cloud.bigquery.storage.v1beta2.StorageError;
import com.google.cloud.bigquery.storage.v1beta2.TableName;
import com.google.cloud.bigquery.storage.v1beta2.WriteStream;
import com.google.protobuf.Descriptors.DescriptorValidationException;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import org.json.JSONArray;
import org.json.JSONObject;

public class WritePendingStream {

  public static void runWritePendingStream()
      throws DescriptorValidationException, InterruptedException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";

    writePendingStream(projectId, datasetName, tableName);
  }

  public static void writePendingStream(String projectId, String datasetName, String tableName)
      throws DescriptorValidationException, InterruptedException, IOException {
    try (BigQueryWriteClient client = BigQueryWriteClient.create()) {
      // Initialize a write stream for the specified table.
      // For more information on WriteStream.Type, see:
      // https://googleapis.dev/java/google-cloud-bigquerystorage/latest/com/google/cloud/bigquery/storage/v1beta2/WriteStream.Type.html
      WriteStream stream = WriteStream.newBuilder().setType(WriteStream.Type.PENDING).build();
      TableName parentTable = TableName.of(projectId, datasetName, tableName);
      CreateWriteStreamRequest createWriteStreamRequest =
          CreateWriteStreamRequest.newBuilder()
              .setParent(parentTable.toString())
              .setWriteStream(stream)
              .build();
      WriteStream writeStream = client.createWriteStream(createWriteStreamRequest);

      // Use the JSON stream writer to send records in JSON format.
      // For more information about JsonStreamWriter, see:
      // https://googleapis.dev/java/google-cloud-bigquerystorage/latest/com/google/cloud/bigquery/storage/v1beta2/JsonStreamWriter.html
      try (JsonStreamWriter writer =
          JsonStreamWriter.newBuilder(writeStream.getName(), writeStream.getTableSchema(), client)
              .build()) {
        // Append 10 JSON objects to the stream.
        for (int i = 0; i < 10; i++) {
          // Create a JSON object that is compatible with the table schema.
          JSONObject record = new JSONObject();
          record.put("col1", String.format("batch-record %03d", i));
          JSONArray jsonArr = new JSONArray();
          jsonArr.put(record);

          ApiFuture<AppendRowsResponse> future = writer.append(jsonArr);
          AppendRowsResponse response = future.get();
        }
        FinalizeWriteStreamResponse finalizeResponse =
            client.finalizeWriteStream(writeStream.getName());
        System.out.println("Rows written: " + finalizeResponse.getRowCount());
      }

      // Commit the streams.
      BatchCommitWriteStreamsRequest commitRequest =
          BatchCommitWriteStreamsRequest.newBuilder()
              .setParent(parentTable.toString())
              .addWriteStreams(writeStream.getName())
              .build();
      BatchCommitWriteStreamsResponse commitResponse =
          client.batchCommitWriteStreams(commitRequest);
      // If the response does not have a commit time, it means the commit operation failed.
      if (commitResponse.hasCommitTime() == false) {
        for (StorageError err : commitResponse.getStreamErrorsList()) {
          System.out.println(err.getErrorMessage());
        }
        throw new RuntimeException("Error committing the streams");
      }
      System.out.println("Appended and committed records successfully.");
    } catch (ExecutionException e) {
      // If the wrapped exception is a StatusRuntimeException, check the state of the operation.
      // If the state is INTERNAL, CANCELLED, or ABORTED, you can retry. For more information, see:
      // https://grpc.github.io/grpc-java/javadoc/io/grpc/StatusRuntimeException.html
      System.out.println(e);
    }
  }
}

Un patrón arquitectónico para usar el modo pendiente es tener un coordinador y varios trabajadores. El coordinador llama a createWriteStream y se lo pasa a un trabajador. Cada trabajador llama a append varias veces según sea necesario y, luego, llama a finalizeWriteStream. Cuando terminan todos los trabajadores, el coordinador llama a batchCommitWriteStream. Debido a que confirmar una transmisión es una operación atómica, si un trabajador falla, otro trabajador puede recoger la misma tarea de procesamiento y volver a intentarlo.

Manejo de errores

Si el método append genera una excepción StatusRuntimeException, debes verificar el código de estado en la excepción. El código de estado puede ser cualquiera de los siguientes:

  • ALREADY_EXISTS: la fila ya se escribió. Este error puede ocurrir cuando proporcionas compensaciones de transmisión. Indica que se detectó un registro duplicado. Puedes ignorar este error con seguridad.
  • INTERNAL, CANCELLED, o ABORTED: no se pudo completar la operación. Puedes volver a intentar la operación de forma segura.
  • INVALID_ARGUMENT: argumento no válido. Este error es un error de aplicación.
  • NOT_FOUND: no se encontró la transmisión o la tabla.
  • OUT_OF_RANGE. La compensación está fuera de la compensación de escritura actual. Este error puede suceder si proporcionas compensaciones de transmisión y no se pudo realizar una operación de escritura anterior. En ese caso, puedes volver a intentarlo desde la última escritura exitosa. Este error también puede ocurrir si la aplicación establece un valor de compensación incorrecto.
  • PERMISSION_DENIED. La aplicación no tiene permiso para escribir en esta tabla.

Si recibes un error que no figura en la lista anterior, intenta abrir una conexión nueva mediante el cierre del objeto de escritor y la creación de una instancia nueva.

Trabaja con esquemas

Cuando creas el objeto de escritor, especificas un esquema. Este esquema debe ser compatible con el esquema de la tabla de BigQuery:

  • Debe incluir todos los campos obligatorios en el esquema de tabla.
  • No puede incluir ningún campo adicional que no esté en el esquema de tabla.
  • Los tipos de datos deben ser compatibles. Para obtener más información, consulta Conversiones de tipos de datos en esta página.

Cuando usas el objeto JsonStreamWriter, proporcionas el esquema como un objeto Schema o TableSchema.

Cuando usas el objeto StreamWriterV2, proporcionas el esquema como un objeto ProtoSchema. El objeto ProtoSchema es un wrapper delgado para un objeto google.protobuf.DescriptorProto que describe el esquema. Puedes usar la clase auxiliar ProtoSchemaConverter para convertir un objeto DescriptorProto en un objeto ProtoSchema autónomo. Además, puedes usar la clase SchemaCompatibility para verificar si el objeto ProtoSchema es compatible con el esquema de la tabla de BigQuery.

Es posible que un esquema de tabla cambie después de que inicias una sesión de escritura. (Para obtener más información sobre los cambios de esquema de tabla, consulta Modifica esquemas de tablas). Si BigQuery detecta un cambio en el esquema, la respuesta AppendRows contiene el esquema actualizado. Para verificar si se actualizó el esquema, llama al método AppendRowsResponse.hasUpdatedSchema.

Con el objeto JsonStreamWriter, puedes comenzar a enviar registros que usen el esquema actualizado después de que hasUpdatedSchema muestre true. No es necesario cerrar la conexión ni volver a configurar el objeto de escritor. Para el objeto StreamWriterV2, cierra la instancia actual y crea una instancia nueva con el esquema actualizado.

Usa la API de gRPC directamente

Aunque te recomendamos usar la biblioteca cliente, también puedes utilizar la API de Storage Write mediante una llamada directa a la API de gRPC, de la siguiente manera:

  1. Llama a CreateWriteStream para crear una transmisión de escritura. Especifica el nombre de la tabla superior y el modo (PENDING o COMMITTED).

  2. En un bucle, llama a AppendRows para adjuntar uno o más registros. Da formato a cada registro como un búfer de protocolo serializado en una secuencia de bytes. De forma opcional, incluye la compensación de escritura. La primera llamada a AppendRows debe contener el esquema de la transmisión, especificado como un objeto DescriptorProto.

  3. En el modo pendiente, llama a FinalizeWriteStream para cada transmisión. Después de llamar a este método, no puedes escribir más filas en la transmisión. Este método no es obligatorio en el modo de confirmación.

  4. En el modo pendiente, después de finalizar las transmisiones, llama a BatchCommitWriteStreams para confirmar las transmisiones. Después de llamar a este método, los datos estarán disponibles para su lectura. Este método no es obligatorio en el modo de confirmación.

Conversiones de tipos de datos

En la siguiente tabla, se muestran los tipos de búfer de protocolo admitidos para cada tipo de datos de BigQuery:

Tipo de datos de BigQuery Tipos de búfer de protocolo admitidos
BOOL bool, int32, int64, uint32, uint64
BYTES bytes
DATE int32 (recomendado), int64

El valor es la cantidad de días transcurridos desde la época Unix (1970-01-01). El rango válido es `-719162` (0001-01-01) a `2932896` (9999-12-31).

DATETIME string

El valor debe ser un literal de DATETIME.

FLOAT double, float
GEOGRAPHY string

El valor es una geometría en formato WKT o GeoJson.

INTEGER int32, int64, uint32, enum
NUMERIC, BIGNUMERIC int32, int64, uint32, uint64, double, float, string

El formato de codificación se documenta en el repositorio de GitHub de ZetaSQL.

STRING string, enum
TIME string

El valor debe ser un literal de TIME.

TIMESTAMP int64 (recomendado), int32, uint32

El valor se proporciona en microsegundos desde la época Unix (1970-01-01).

Cuotas de la API de Storage Write

Para obtener información sobre las cuotas y los límites de la API de Storage Write, consulta las solicitudes de API de BigQuery Storage Write.

Precios de la API de Storage Write

Para obtener información sobre los precios, consulta Precios de transferencia de datos.

Regiones admitidas

La fase de vista previa de la API de Storage Write es compatible con las siguientes ubicaciones.

Ubicaciones regionales

Descripción de la región Nombre de la región
América
Carolina del Sur us-east1
Europa
Bélgica europe-west1
Asia-Pacífico
Sídney australia-southeast1
Tokio asia-northeast1

Ubicaciones multirregionales

Descripción de la multirregión Nombre de la multirregión
Centros de datos dentro de Estados miembros de la Unión Europea EU
Centros de datos en Estados Unidos US