Class v1.BigQueryWriteClient (4.1.0)

Package

Constructors

(constructor)(opts, gaxInstance)

constructor(opts?: ClientOptions, gaxInstance?: typeof gax | typeof gax.fallback);

Properties

apiEndpoint

static get apiEndpoint(): string;

auth

auth: gax.GoogleAuth;

bigQueryWriteStub

bigQueryWriteStub?: Promise<{
        [name: string]: Function;
    }>;

descriptors

descriptors: Descriptors;

innerApiCalls

innerApiCalls: {
        [name: string]: Function;
    };

pathTemplates

pathTemplates: {
        [name: string]: gax.PathTemplate;
    };

port

static get port(): number;

scopes

static get scopes(): string[];

servicePath

static get servicePath(): string;

warn

warn: (code: string, message: string, warnType?: string) => void;

Methods

appendRows(options)

appendRows(options?: CallOptions): gax.CancellableStream;

  /**
   * 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 write_stream identifies the target of the append operation,
   *  and only needs to be specified as part of the first request on the gRPC
   *  connection. If provided for subsequent requests, it must match the value of
   *  the first request.
   *  For explicitly created write streams, the format is:
   *  * `projects/{project}/datasets/{dataset}/tables/{table}/streams/{id}`
   *  For the special default stream, the format is:
   *  * `projects/{project}/datasets/{dataset}/tables/{table}/streams/_default`.
   */
  // const writeStream = 'abc123'
  /**
   *  If present, the write is only performed if the next append offset is same
   *  as the provided value. If not present, the write is performed at the
   *  current end of stream. Specifying a value for this field is not allowed
   *  when calling AppendRows for the '_default' stream.
   */
  // const offset = {}
  /**
   *  Rows in proto format.
   */
  // const protoRows = {}
  /**
   *  Id set by client to annotate its identity. Only initial request setting is
   *  respected.
   */
  // const traceId = 'abc123'
  /**
   *  A map to indicate how to interpret missing value for some fields. Missing
   *  values are fields present in user schema but missing in rows. The key is
   *  the field name. The value is the interpretation of missing values for the
   *  field.
   *  For example, a map {'foo': NULL_VALUE, 'bar': DEFAULT_VALUE} means all
   *  missing values in field foo are interpreted as NULL, all missing values in
   *  field bar are interpreted as the default value of field bar in table
   *  schema.
   *  If a field is not in this map and has missing values, the missing values
   *  in this field are interpreted as NULL.
   *  This field only applies to the current request, it won't affect other
   *  requests on the connection.
   *  Currently, field name can only be top-level column name, can't be a struct
   *  field path like 'foo.bar'.
   */
  // const missingValueInterpretations = 1234

  // Imports the Storage library
  const {BigQueryWriteClient} = require('@google-cloud/bigquery-storage').v1;

  // Instantiates a client
  const storageClient = new BigQueryWriteClient();

  async function callAppendRows() {
    // Construct request
    const request = {
      writeStream,
    };

    // Run request
    const stream = await storageClient.appendRows();
    stream.on('data', (response) => { console.log(response) });
    stream.on('error', (err) => { throw(err) });
    stream.on('end', () => { /* API call completed */ });
    stream.write(request);
    stream.end(); 
  }

  callAppendRows();

batchCommitWriteStreams(request, options)

batchCommitWriteStreams(request?: protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsResponse,
        (protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsRequest | undefined),
        {} | undefined
    ]>;

  /**
   * 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. Parent table that all the streams should belong to, in the form
   *  of `projects/{project}/datasets/{dataset}/tables/{table}`.
   */
  // const parent = 'abc123'
  /**
   *  Required. The group of streams that will be committed atomically.
   */
  // const writeStreams = 'abc123'

  // Imports the Storage library
  const {BigQueryWriteClient} = require('@google-cloud/bigquery-storage').v1;

  // Instantiates a client
  const storageClient = new BigQueryWriteClient();

  async function callBatchCommitWriteStreams() {
    // Construct request
    const request = {
      parent,
      writeStreams,
    };

    // Run request
    const response = await storageClient.batchCommitWriteStreams(request);
    console.log(response);
  }

  callBatchCommitWriteStreams();

batchCommitWriteStreams(request, options, callback)

batchCommitWriteStreams(request: protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsRequest, options: CallOptions, callback: Callback<protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsResponse, protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsRequest | null | undefined, {} | null | undefined>): void;

batchCommitWriteStreams(request, callback)

batchCommitWriteStreams(request: protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsRequest, callback: Callback<protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsResponse, protos.google.cloud.bigquery.storage.v1.IBatchCommitWriteStreamsRequest | null | undefined, {} | null | undefined>): void;

close()

close(): Promise<void>;

createWriteStream(request, options)

createWriteStream(request?: protos.google.cloud.bigquery.storage.v1.ICreateWriteStreamRequest, options?: CallOptions): Promise<[
        protos.google.cloud.bigquery.storage.v1.IWriteStream,
        (protos.google.cloud.bigquery.storage.v1.ICreateWriteStreamRequest | undefined),
        {} | undefined
    ]>;

  /**
   * 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. Reference to the table to which the stream belongs, in the format
   *  of `projects/{project}/datasets/{dataset}/tables/{table}`.
   */
  // const parent = 'abc123'
  /**
   *  Required. Stream to be created.
   */
  // const writeStream = {}

  // Imports the Storage library
  const {BigQueryWriteClient} = require('@google-cloud/bigquery-storage').v1;

  // Instantiates a client
  const storageClient = new BigQueryWriteClient();

  async function callCreateWriteStream() {
    // Construct request
    const request = {
      parent,
      writeStream,
    };

    // Run request
    const response = await storageClient.createWriteStream(request);
    console.log(response);
  }

  callCreateWriteStream();

createWriteStream(request, options, callback)

createWriteStream(request: protos.google.cloud.bigquery.storage.v1.ICreateWriteStreamRequest, options: CallOptions, callback: Callback<protos.google.cloud.bigquery.storage.v1.IWriteStream, protos.google.cloud.bigquery.storage.v1.ICreateWriteStreamRequest | null | undefined, {} | null | undefined>): void;

createWriteStream(request, callback)

createWriteStream(request: protos.google.cloud.bigquery.storage.v1.ICreateWriteStreamRequest, callback: Callback<protos.google.cloud.bigquery.storage.v1.IWriteStream, protos.google.cloud.bigquery.storage.v1.ICreateWriteStreamRequest | null | undefined, {} | null | undefined>): void;

finalizeWriteStream(request, options)

finalizeWriteStream(request?: protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamRequest, options?: CallOptions): Promise<[
        protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamResponse,
        (protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamRequest | undefined),
        {} | undefined
    ]>;

  /**
   * 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. Name of the stream to finalize, in the form of
   *  `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
   */
  // const name = 'abc123'

  // Imports the Storage library
  const {BigQueryWriteClient} = require('@google-cloud/bigquery-storage').v1;

  // Instantiates a client
  const storageClient = new BigQueryWriteClient();

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

    // Run request
    const response = await storageClient.finalizeWriteStream(request);
    console.log(response);
  }

  callFinalizeWriteStream();

finalizeWriteStream(request, options, callback)

finalizeWriteStream(request: protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamRequest, options: CallOptions, callback: Callback<protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamResponse, protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamRequest | null | undefined, {} | null | undefined>): void;

finalizeWriteStream(request, callback)

finalizeWriteStream(request: protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamRequest, callback: Callback<protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamResponse, protos.google.cloud.bigquery.storage.v1.IFinalizeWriteStreamRequest | null | undefined, {} | null | undefined>): void;

flushRows(request, options)

flushRows(request?: protos.google.cloud.bigquery.storage.v1.IFlushRowsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.bigquery.storage.v1.IFlushRowsResponse,
        protos.google.cloud.bigquery.storage.v1.IFlushRowsRequest | undefined,
        {} | undefined
    ]>;

  /**
   * 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 stream that is the target of the flush operation.
   */
  // const writeStream = 'abc123'
  /**
   *  Ending offset of the flush operation. Rows before this offset(including
   *  this offset) will be flushed.
   */
  // const offset = {}

  // Imports the Storage library
  const {BigQueryWriteClient} = require('@google-cloud/bigquery-storage').v1;

  // Instantiates a client
  const storageClient = new BigQueryWriteClient();

  async function callFlushRows() {
    // Construct request
    const request = {
      writeStream,
    };

    // Run request
    const response = await storageClient.flushRows(request);
    console.log(response);
  }

  callFlushRows();

flushRows(request, options, callback)

flushRows(request: protos.google.cloud.bigquery.storage.v1.IFlushRowsRequest, options: CallOptions, callback: Callback<protos.google.cloud.bigquery.storage.v1.IFlushRowsResponse, protos.google.cloud.bigquery.storage.v1.IFlushRowsRequest | null | undefined, {} | null | undefined>): void;

flushRows(request, callback)

flushRows(request: protos.google.cloud.bigquery.storage.v1.IFlushRowsRequest, callback: Callback<protos.google.cloud.bigquery.storage.v1.IFlushRowsResponse, protos.google.cloud.bigquery.storage.v1.IFlushRowsRequest | null | undefined, {} | null | undefined>): void;

getProjectId()

getProjectId(): Promise<string>;

getProjectId(callback)

getProjectId(callback: Callback<string, undefined, undefined>): void;

getWriteStream(request, options)

getWriteStream(request?: protos.google.cloud.bigquery.storage.v1.IGetWriteStreamRequest, options?: CallOptions): Promise<[
        protos.google.cloud.bigquery.storage.v1.IWriteStream,
        (protos.google.cloud.bigquery.storage.v1.IGetWriteStreamRequest | undefined),
        {} | undefined
    ]>;

  /**
   * 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. Name of the stream to get, in the form of
   *  `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
   */
  // const name = 'abc123'
  /**
   *  Indicates whether to get full or partial view of the WriteStream. If
   *  not set, view returned will be basic.
   */
  // const view = {}

  // Imports the Storage library
  const {BigQueryWriteClient} = require('@google-cloud/bigquery-storage').v1;

  // Instantiates a client
  const storageClient = new BigQueryWriteClient();

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

    // Run request
    const response = await storageClient.getWriteStream(request);
    console.log(response);
  }

  callGetWriteStream();

getWriteStream(request, options, callback)

getWriteStream(request: protos.google.cloud.bigquery.storage.v1.IGetWriteStreamRequest, options: CallOptions, callback: Callback<protos.google.cloud.bigquery.storage.v1.IWriteStream, protos.google.cloud.bigquery.storage.v1.IGetWriteStreamRequest | null | undefined, {} | null | undefined>): void;

getWriteStream(request, callback)

getWriteStream(request: protos.google.cloud.bigquery.storage.v1.IGetWriteStreamRequest, callback: Callback<protos.google.cloud.bigquery.storage.v1.IWriteStream, protos.google.cloud.bigquery.storage.v1.IGetWriteStreamRequest | null | undefined, {} | null | undefined>): void;

initialize()

initialize(): Promise<{
        [name: string]: Function;
    }>;

matchDatasetFromTableName(tableName)

matchDatasetFromTableName(tableName: string): string | number;

matchDatasetFromWriteStreamName(writeStreamName)

matchDatasetFromWriteStreamName(writeStreamName: string): string | number;

matchLocationFromReadSessionName(readSessionName)

matchLocationFromReadSessionName(readSessionName: string): string | number;

matchLocationFromReadStreamName(readStreamName)

matchLocationFromReadStreamName(readStreamName: string): string | number;

matchProjectFromProjectName(projectName)

matchProjectFromProjectName(projectName: string): string | number;

matchProjectFromReadSessionName(readSessionName)

matchProjectFromReadSessionName(readSessionName: string): string | number;

matchProjectFromReadStreamName(readStreamName)

matchProjectFromReadStreamName(readStreamName: string): string | number;

matchProjectFromTableName(tableName)

matchProjectFromTableName(tableName: string): string | number;

matchProjectFromWriteStreamName(writeStreamName)

matchProjectFromWriteStreamName(writeStreamName: string): string | number;

matchSessionFromReadSessionName(readSessionName)

matchSessionFromReadSessionName(readSessionName: string): string | number;

matchSessionFromReadStreamName(readStreamName)

matchSessionFromReadStreamName(readStreamName: string): string | number;

matchStreamFromReadStreamName(readStreamName)

matchStreamFromReadStreamName(readStreamName: string): string | number;

matchStreamFromWriteStreamName(writeStreamName)

matchStreamFromWriteStreamName(writeStreamName: string): string | number;

matchTableFromTableName(tableName)

matchTableFromTableName(tableName: string): string | number;

matchTableFromWriteStreamName(writeStreamName)

matchTableFromWriteStreamName(writeStreamName: string): string | number;

projectPath(project)

projectPath(project: string): string;

readSessionPath(project, location, session)

readSessionPath(project: string, location: string, session: string): string;

readStreamPath(project, location, session, stream)

readStreamPath(project: string, location: string, session: string, stream: string): string;

tablePath(project, dataset, table)

tablePath(project: string, dataset: string, table: string): string;

writeStreamPath(project, dataset, table, stream)

writeStreamPath(project: string, dataset: string, table: string, stream: string): string;