@google-cloud/bigquery

  • Version 7.7.0
  • Published
  • 727 kB
  • 11 dependencies
  • Apache-2.0 license

Install

npm i @google-cloud/bigquery
yarn add @google-cloud/bigquery
pnpm add @google-cloud/bigquery

Overview

Google BigQuery Client Library for Node.js

Index

Variables

Classes

Interfaces

Type Aliases

Variables

variable PROTOCOL_REGEX

const PROTOCOL_REGEX: RegExp;

    Classes

    class BigQuery

    class BigQuery extends Service {}
    • In the following examples from this page and the other modules (Dataset, Table, etc.), we are going to be using a dataset from data.gov of higher education institutions.

      We will create a table with the correct schema, import the public CSV file into that table, and query it for data.

      This client supports enabling query-related preview features via environmental variables. By setting the environment variable QUERY_PREVIEW_ENABLED to the string "TRUE", the client will enable preview features, though behavior may still be controlled via the bigquery service as well. Currently, the feature(s) in scope include: stateless queries (query execution without corresponding job metadata).

      See What is BigQuery?

      Parameter options

      Constructor options.

      Example 1

      Install the client library with npm:

      npm install @google-cloud/bigquery

      Example 2

      Import the client library

      const {BigQuery} = require('@google-cloud/bigquery');

      Example 3

      Create a client that uses Application Default Credentials (ADC):

      const bigquery = new BigQuery();

      Example 4

      Create a client with explicit credentials:

      const bigquery = new BigQuery({
      projectId: 'your-project-id',
      keyFilename: '/path/to/keyfile.json'
      });

      Example 5

      include:samples/quickstart.js region_tag:bigquery_quickstart Full quickstart example:

    constructor

    constructor(options?: BigQueryOptions);

      property location

      location?: string;

        property setLogFunction

        static setLogFunction: (logger: (msg: string) => void) => void;

          property universeDomain

          readonly universeDomain: string;

            method createDataset

            createDataset: {
            (id: string, options?: DatasetResource): Promise<DatasetResponse>;
            (id: string, options: DatasetResource, callback: DatasetCallback): void;
            (id: string, callback: DatasetCallback): void;
            };
            • Create a dataset.

              See Datasets: insert API Documentation

              Parameter id

              ID of the dataset to create.

              Parameter options

              See a Dataset resource.

              Parameter callback

              The callback function.

              Parameter

              {?error} callback.err An error returned while making this request

              Parameter

              {Dataset} callback.dataset The newly created dataset

              Parameter

              {object} callback.apiResponse The full API response.

              Example 1

              const {BigQuery} = require('@google-cloud/bigquery');
              const bigquery = new BigQuery();
              bigquery.createDataset('my-dataset', function(err, dataset, apiResponse)
              {});
              //-
              // If the callback is omitted, we'll return a Promise.
              //-
              bigquery.createDataset('my-dataset').then(function(data) {
              const dataset = data[0];
              const apiResponse = data[1];
              });

            method createJob

            createJob: {
            (options: JobOptions): Promise<JobResponse>;
            (options: JobOptions, callback: JobCallback): void;
            };
            • Creates a job. Typically when creating a job you'll have a very specific task in mind. For this we recommend one of the following methods:

              - BigQuery.createQueryJob - Table#createCopyJob - Table#createCopyFromJob - Table#createExtractJob - Table#createLoadJob

              However in the event you need a finer level of control over the job creation, you can use this method to pass in a raw Job resource object.

              See Jobs Overview See Jobs: insert API Documentation

              Parameter options

              Object in the form of a Job resource;

              Parameter

              {string} [options.jobId] Custom job id.

              Parameter

              {string} [options.jobPrefix] Prefix to apply to the job id.

              Parameter

              {string} [options.location] The geographic location of the job. Required except for US and EU.

              Parameter callback

              The callback function.

              Parameter

              {?error} callback.err An error returned while making this request.

              Parameter

              {Job} callback.job The newly created job.

              Parameter

              {object} callback.apiResponse The full API response.

              Example 1

              const {BigQuery} = require('@google-cloud/bigquery');
              const bigquery = new BigQuery();
              const options = {
              configuration: {
              query: {
              query: 'SELECT url FROM `publicdata.samples.github_nested` LIMIT 100'
              }
              }
              };
              bigquery.createJob(options, function(err, job) {
              if (err) {
              // Error handling omitted.
              }
              job.getQueryResults(function(err, rows) {});
              });
              //-
              // If the callback is omitted, we'll return a Promise.
              //-
              bigquery.createJob(options).then(function(data) {
              const job = data[0];
              return job.getQueryResults();
              });

            method createQueryJob

            createQueryJob: {
            (options: Query | string): Promise<JobResponse>;
            (options: string | Query, callback: JobCallback): void;
            };
            • Run a query as a job. No results are immediately returned. Instead, your callback will be executed with a Job object that you must ping for the results. See the Job documentation for explanations of how to check on the status of the job.

              See Jobs: insert API Documentation

              Parameter options

              The configuration object. This must be in the format of the `configuration.query` property of a Jobs resource. If a string is provided, this is used as the query string, and all other options are defaulted.

              Parameter

              {Table} [options.destination] The table to save the query's results to. If omitted, a new table will be created.

              Parameter

              {boolean} [options.dryRun] If set, don't actually run this job. A valid query will update the job with processing statistics. These can be accessed via job.metadata.

              Parameter

              {object} [options.labels] String key/value pairs to be attached as labels to the newly created Job.

              Parameter

              {string} [options.location] The geographic location of the job. Required except for US and EU.

              Parameter

              {number} [options.jobTimeoutMs] Job timeout in milliseconds. If this time limit is exceeded, BigQuery might attempt to stop the job.

              Parameter

              {string} [options.jobId] Custom job id.

              Parameter

              {string} [options.jobPrefix] Prefix to apply to the job id.

              Parameter

              {string} options.query A query string, following the BigQuery query syntax, of the query to execute.

              Parameter

              {boolean} [options.useLegacySql=false] Option to use legacy sql syntax.

              Parameter

              {object} [options.defaultDataset] The dataset. This must be in the format of the `DatasetReference`

              Parameter

              {boolean} [options.wrapIntegers] Optionally wrap INT64 in BigQueryInt or custom INT64 value type.

              Parameter

              {boolean} [options.parseJSON] Optionally parse JSON as a JSON Object.

              Parameter

              {object|array} [options.params] Option to provide query prarameters.

              Parameter callback

              The callback function.

              Parameter

              {?error} callback.err An error returned while making this request.

              Parameter

              {Job} callback.job The newly created job for your query.

              Parameter

              {object} callback.apiResponse The full API response.

              Throws

              {Error} If a query is not specified.

              Throws

              {Error} If a Table is not provided as a destination.

              Example 1

              const {BigQuery} = require('@google-cloud/bigquery');
              const bigquery = new BigQuery();
              const query = 'SELECT url FROM `publicdata.samples.github_nested` LIMIT
              100';
              //-
              // You may pass only a query string, having a new table created to store
              the
              // results of the query.
              //-
              bigquery.createQueryJob(query, function(err, job) {});
              //-
              // You can also control the destination table by providing a
              // {@link Table} object.
              //-
              bigquery.createQueryJob({
              destination: bigquery.dataset('higher_education').table('institutions'),
              query: query
              }, function(err, job) {});
              //-
              // After you have run `createQueryJob`, your query will execute in a job.
              Your
              // callback is executed with a {@link Job} object so that you may
              // check for the results.
              //-
              bigquery.createQueryJob(query, function(err, job) {
              if (!err) {
              job.getQueryResults(function(err, rows, apiResponse) {});
              }
              });
              //-
              // If the callback is omitted, we'll return a Promise.
              //-
              bigquery.createQueryJob(query).then(function(data) {
              const job = data[0];
              const apiResponse = data[1];
              return job.getQueryResults();
              });

            method createQueryStream

            createQueryStream: (options?: Query | string) => ResourceStream<any>;

              method dataset

              dataset: (id: string, options?: DatasetOptions) => Dataset;
              • Create a reference to a dataset.

                Parameter id

                ID of the dataset.

                Parameter options

                Dataset options.

                Parameter

                {string} [options.projectId] The GCP project ID.

                Parameter

                {string} [options.location] The geographic location of the dataset. Required except for US and EU.

                Example 1

                const {BigQuery} = require('@google-cloud/bigquery');
                const bigquery = new BigQuery();
                const dataset = bigquery.dataset('higher_education');

              method date

              static date: (value: BigQueryDateOptions | string) => BigQueryDate;
              • The DATE type represents a logical calendar date, independent of time zone. It does not represent a specific 24-hour time period. Rather, a given DATE value represents a different 24-hour period when interpreted in different time zones, and may represent a shorter or longer day during Daylight Savings Time transitions.

                Parameter value

                The date. If a string, this should be in the format the API describes: YYYY-[M]M-[D]D. Otherwise, provide an object.

                Parameter

                {string|number} value.year Four digits.

                Parameter

                {string|number} value.month One or two digits.

                Parameter

                {string|number} value.day One or two digits.

                Example 1

                const {BigQuery} = require('@google-cloud/bigquery');
                const bigquery = new BigQuery();
                const date = bigquery.date('2017-01-01');
                //-
                // Alternatively, provide an object.
                //-
                const date2 = bigquery.date({
                year: 2017,
                month: 1,
                day: 1
                });
              • Parameter value

                The date. If a string, this should be in the format the API describes: YYYY-[M]M-[D]D. Otherwise, provide an object.

                Parameter

                {string|number} value.year Four digits.

                Parameter

                {string|number} value.month One or two digits.

                Parameter

                {string|number} value.day One or two digits.

                Example 1

                const {BigQuery} = require('@google-cloud/bigquery');
                const date = BigQuery.date('2017-01-01');
                //-
                // Alternatively, provide an object.
                //-
                const date2 = BigQuery.date({
                year: 2017,
                month: 1,
                day: 1
                });

              method datetime

              static datetime: (value: BigQueryDatetimeOptions | string) => BigQueryDatetime;
              • A DATETIME data type represents a point in time. Unlike a TIMESTAMP, this does not refer to an absolute instance in time. Instead, it is the civil time, or the time that a user would see on a watch or calendar.

                Parameter value

                The time. If a string, this should be in the format the API describes: YYYY-[M]M-[D]D[ [H]H:[M]M:[S]S[.DDDDDD]]. Otherwise, provide an object.

                Parameter

                {string|number} value.year Four digits.

                Parameter

                {string|number} value.month One or two digits.

                Parameter

                {string|number} value.day One or two digits.

                Parameter

                {string|number} [value.hours] One or two digits (00 - 23).

                Parameter

                {string|number} [value.minutes] One or two digits (00 - 59).

                Parameter

                {string|number} [value.seconds] One or two digits (00 - 59).

                Parameter

                {string|number} [value.fractional] Up to six digits for microsecond precision.

                Example 1

                const {BigQuery} = require('@google-cloud/bigquery');
                const bigquery = new BigQuery();
                const datetime = bigquery.datetime('2017-01-01 13:00:00');
                //-
                // Alternatively, provide an object.
                //-
                const datetime = bigquery.datetime({
                year: 2017,
                month: 1,
                day: 1,
                hours: 14,
                minutes: 0,
                seconds: 0
                });

              method decodeIntegerValue_

              static decodeIntegerValue_: (value: IntegerTypeCastValue) => number;
              • Convert an INT64 value to Number.

                Parameter value

                The INT64 value to convert.

              method geography

              static geography: (value: string) => Geography;
              • A geography value represents a surface area on the Earth in Well-known Text (WKT) format.

                Parameter value

                The geospatial data.

                Example 1

                const {BigQuery} = require('@google-cloud/bigquery');
                const bigquery = new BigQuery();
                const geography = bigquery.geography('POINT(1, 2)');

              method getDatasets

              getDatasets: {
              (options?: GetDatasetsOptions): Promise<DatasetsResponse>;
              (options: GetDatasetsOptions, callback: DatasetsCallback): void;
              (callback: DatasetsCallback): void;
              };
              • List all or some of the datasets in a project.

                See Datasets: list API Documentation

                Parameter options

                Configuration object.

                Parameter

                {boolean} [options.all] List all datasets, including hidden ones.

                Parameter

                {string} [options.projectId] The GCP project ID.

                Parameter

                {boolean} [options.autoPaginate] Have pagination handled automatically. Default: true.

                Parameter

                {number} [options.maxApiCalls] Maximum number of API calls to make.

                Parameter

                {number} [options.maxResults] Maximum number of results to return.

                Parameter

                {string} [options.pageToken] Token returned from a previous call, to request the next page of results.

                Parameter callback

                The callback function.

                Parameter

                {?error} callback.err An error returned while making this request

                Parameter

                {Dataset[]} callback.datasets The list of datasets in your project.

                Example 1

                const {BigQuery} = require('@google-cloud/bigquery');
                const bigquery = new BigQuery();
                bigquery.getDatasets(function(err, datasets) {
                if (!err) {
                // datasets is an array of Dataset objects.
                }
                });
                //-
                // To control how many API requests are made and page through the results
                // manually, set `autoPaginate` to `false`.
                //-
                function manualPaginationCallback(err, datasets, nextQuery, apiResponse) {
                if (nextQuery) {
                // More results exist.
                bigquery.getDatasets(nextQuery, manualPaginationCallback);
                }
                }
                bigquery.getDatasets({
                autoPaginate: false
                }, manualPaginationCallback);
                //-
                // If the callback is omitted, we'll return a Promise.
                //-
                bigquery.getDatasets().then(function(datasets) {});

              method getDatasetsStream

              getDatasetsStream: (options?: GetDatasetsOptions) => ResourceStream<Dataset>;

                method getJobs

                getJobs: {
                (options?: GetJobsOptions): Promise<GetJobsResponse>;
                (options: GetJobsOptions, callback: GetJobsCallback): void;
                (callback: GetJobsCallback): void;
                };
                • Get all of the jobs from your project.

                  See Jobs: list API Documentation

                  Parameter options

                  Configuration object.

                  Parameter

                  {boolean} [options.allUsers] Display jobs owned by all users in the project.

                  Parameter

                  {boolean} [options.autoPaginate] Have pagination handled automatically. Default: true.

                  Parameter

                  {number} [options.maxApiCalls] Maximum number of API calls to make.

                  Parameter

                  {number} [options.maxResults] Maximum number of results to return.

                  Parameter

                  {string} [options.pageToken] Token returned from a previous call, to request the next page of results.

                  Parameter

                  {string} [options.projection] Restrict information returned to a set of selected fields. Acceptable values are "full", for all job data, and "minimal", to not include the job configuration.

                  Parameter

                  {string} [options.stateFilter] Filter for job state. Acceptable values are "done", "pending", and "running". Sending an array to this option performs a disjunction.

                  Parameter callback

                  The callback function.

                  Parameter

                  {?error} callback.err An error returned while making this request

                  Parameter

                  {Job[]} callback.jobs The list of jobs in your project.

                  Example 1

                  const {BigQuery} = require('@google-cloud/bigquery');
                  const bigquery = new BigQuery();
                  bigquery.getJobs(function(err, jobs) {
                  if (!err) {
                  // jobs is an array of Job objects.
                  }
                  });
                  //-
                  // To control how many API requests are made and page through the results
                  // manually, set `autoPaginate` to `false`.
                  //-
                  function manualPaginationCallback(err, jobs, nextQuery, apiRespose) {
                  if (nextQuery) {
                  // More results exist.
                  bigquery.getJobs(nextQuery, manualPaginationCallback);
                  }
                  }
                  bigquery.getJobs({
                  autoPaginate: false
                  }, manualPaginationCallback);
                  //-
                  // If the callback is omitted, we'll return a Promise.
                  //-
                  bigquery.getJobs().then(function(data) {
                  const jobs = data[0];
                  });

                method getJobsStream

                getJobsStream: (options?: GetJobsOptions) => ResourceStream<Job>;

                  method getTypeDescriptorFromProvidedType_

                  static getTypeDescriptorFromProvidedType_: (
                  providedType: string | ProvidedTypeStruct | ProvidedTypeArray
                  ) => ValueType;
                  • Return a value's provided type.

                    Parameter providedType

                    The type.

                    Returns

                    {string} The valid type provided.

                    Throws

                    {error} If the type provided is invalid.

                    See Data Type

                  method getTypeDescriptorFromValue_

                  static getTypeDescriptorFromValue_: (value: unknown) => ValueType;
                  • Detect a value's type.

                    Parameter value

                    The value.

                    Returns

                    {string} The type detected from the value.

                    Throws

                    {error} If the type could not be detected.

                    See Data Type

                  method int

                  static int: (
                  value: string | number | IntegerTypeCastValue,
                  typeCastOptions?: IntegerTypeCastOptions
                  ) => BigQueryInt;
                  • A BigQueryInt wraps 'INT64' values. Can be used to maintain precision.

                    Parameter value

                    The INT64 value to convert.

                    Parameter typeCastOptions

                    Configuration to convert value. Must provide an integerTypeCastFunction to handle conversion.

                    Returns

                    {BigQueryInt}

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const bigquery = new BigQuery();
                    const largeIntegerValue = Number.MAX_SAFE_INTEGER + 1;
                    const options = {
                    integerTypeCastFunction: value => value.split(),
                    };
                    const bqInteger = bigquery.int(largeIntegerValue, options);
                    const customValue = bqInteger.valueOf();
                    // customValue is the value returned from your `integerTypeCastFunction`.

                  method job

                  job: (id: string, options?: JobOptions) => Job;
                  • Create a reference to an existing job.

                    Parameter id

                    ID of the job.

                    Parameter options

                    Configuration object.

                    Parameter

                    {string} [options.location] The geographic location of the job. Required except for US and EU.

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const bigquery = new BigQuery();
                    const myExistingJob = bigquery.job('job-id');

                  method mergeSchemaWithRows_

                  static mergeSchemaWithRows_: (
                  schema: TableSchema | TableField,
                  rows: TableRow[],
                  options: {
                  wrapIntegers: boolean | IntegerTypeCastOptions;
                  selectedFields?: string[];
                  parseJSON?: boolean;
                  }
                  ) => any[];
                  • Merge a rowset returned from the API with a table schema.

                    Parameter schema

                    Parameter rows

                    Parameter options

                    Parameter

                    {boolean|IntegerTypeCastOptions} options.wrapIntegers Wrap values of 'INT64' type in BigQueryInt objects. If a boolean, this will wrap values in BigQueryInt objects. If an object, this will return a value returned by wrapIntegers.integerTypeCastFunction. Please see IntegerTypeCastOptions for options descriptions.

                    Parameter

                    {array} options.selectedFields List of fields to return. If unspecified, all fields are returned.

                    Parameter

                    {array} options.parseJSON parse a 'JSON' field into a JSON object.

                    Returns

                    Fields using their matching names from the table's schema.

                  method query

                  query: {
                  (query: string, options?: QueryOptions): Promise<QueryRowsResponse>;
                  (
                  query: Query,
                  options?: QueryResultsOptions
                  ): Promise<SimpleQueryRowsResponse>;
                  (
                  query: string,
                  options: QueryResultsOptions,
                  callback?: QueryRowsCallback
                  ): void;
                  (
                  query: Query,
                  options: QueryResultsOptions,
                  callback?: SimpleQueryRowsCallback
                  ): void;
                  (query: string, callback?: QueryRowsCallback): void;
                  (query: Query, callback?: SimpleQueryRowsCallback): void;
                  };
                  • Run a query scoped to your project. For manual pagination please refer to BigQuery.createQueryJob.

                    See Jobs: query API Documentation

                    Parameter query

                    A string SQL query or configuration object. For all available options, see Jobs: query request body.

                    Parameter

                    {string} [query.location] The geographic location of the job. Required except for US and EU.

                    Parameter

                    {string} [query.jobId] Custom id for the underlying job.

                    Parameter

                    {string} [query.jobPrefix] Prefix to apply to the underlying job id.

                    Parameter

                    {object|Array<*>} query.params For positional SQL parameters, provide an array of values. For named SQL parameters, provide an object which maps each named parameter to its value. The supported types are integers, floats, BigQuery.date objects, BigQuery.datetime objects, BigQuery.time objects, BigQuery.timestamp objects, Strings, Booleans, and Objects.

                    Parameter

                    {string} query.query A query string, following the BigQuery query syntax, of the query to execute.

                    Parameter

                    {object|Array<*>} query.types Provided types for query parameters. For positional SQL parameters, provide an array of types. For named SQL parameters, provide an object which maps each named parameter to its type.

                    Parameter

                    {boolean} [query.useLegacySql=false] Option to use legacy sql syntax.

                    Parameter options

                    Configuration object for query results.

                    Parameter

                    {number} [options.maxResults] Maximum number of results to read.

                    Parameter

                    {number} [options.timeoutMs] How long to wait for the query to complete, in milliseconds, before returning. Default is 10 seconds. If the timeout passes before the job completes, an error will be returned and the 'jobComplete' field in the response will be false.

                    Parameter

                    {boolean|IntegerTypeCastOptions} [options.wrapIntegers=false] Wrap values of 'INT64' type in BigQueryInt objects. If a boolean, this will wrap values in BigQueryInt objects. If an object, this will return a value returned by wrapIntegers.integerTypeCastFunction. Please see IntegerTypeCastOptions for options descriptions.

                    Parameter callback

                    The callback function.

                    Parameter

                    {?error} callback.err An error returned while making this request

                    Parameter

                    {array} callback.rows The list of results from your query.

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const bigquery = new BigQuery();
                    const query = 'SELECT url FROM `publicdata.samples.github_nested` LIMIT
                    100';
                    bigquery.query(query, function(err, rows) {
                    if (!err) {
                    // rows is an array of results.
                    }
                    });
                    //-
                    // Positional SQL parameters are supported.
                    //-
                    bigquery.query({
                    query: [
                    'SELECT url',
                    'FROM `publicdata.samples.github_nested`',
                    'WHERE repository.owner = ?'
                    ].join(' '),
                    params: [
                    'google'
                    ]
                    }, function(err, rows) {});
                    //-
                    // Or if you prefer to name them, that's also supported.
                    //-
                    bigquery.query({
                    query: [
                    'SELECT url',
                    'FROM `publicdata.samples.github_nested`',
                    'WHERE repository.owner = @owner'
                    ].join(' '),
                    params: {
                    owner: 'google'
                    }
                    }, function(err, rows) {});
                    //-
                    // Providing types for SQL parameters is supported.
                    //-
                    bigquery.query({
                    query: [
                    'SELECT url',
                    'FROM `publicdata.samples.github_nested`',
                    'WHERE repository.owner = ?'
                    ].join(' '),
                    params: [
                    null
                    ],
                    types: ['string']
                    }, function(err, rows) {});
                    //-
                    // If you need to use a `DATE`, `DATETIME`, `TIME`, or `TIMESTAMP` type in
                    // your query, see {@link BigQuery.date}, {@link BigQuery.datetime},
                    // {@link BigQuery.time}, and {@link BigQuery.timestamp}.
                    //-
                    //-
                    // If the callback is omitted, we'll return a Promise.
                    //-
                    bigquery.query(query).then(function(data) {
                    const rows = data[0];
                    });

                  method queryAsStream_

                  queryAsStream_: (query: Query, callback?: SimpleQueryRowsCallback) => void;
                  • This method will be called by createQueryStream(). It is required to properly set the autoPaginate option value.

                  method range

                  static range: (
                  value: string | BigQueryRangeOptions,
                  elementType?: string
                  ) => BigQueryRange;
                  • A range represents contiguous range between two dates, datetimes, or timestamps. The lower and upper bound for the range are optional. The lower bound is inclusive and the upper bound is exclusive.

                    BigQuery.range

                    Parameter value

                    The range API string or start/end with dates/datetimes/timestamp ranges.

                    Parameter elementType

                    The range element type - DATE|DATETIME|TIMESTAMP

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const timestampRange = BigQuery.range('[2020-10-01 12:00:00+08, 2020-12-31 12:00:00+08)', 'TIMESTAMP');
                  • A range represents contiguous range between two dates, datetimes, or timestamps. The lower and upper bound for the range are optional. The lower bound is inclusive and the upper bound is exclusive.

                    Parameter value

                    The range API string or start/end with dates/datetimes/timestamp ranges.

                    Parameter elementType

                    The range element type - DATE|DATETIME|TIMESTAMP

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const bigquery = new BigQuery();
                    const timestampRange = bigquery.range('[2020-10-01 12:00:00+08, 2020-12-31 12:00:00+08)', 'TIMESTAMP');

                  method time

                  static time: (value: BigQueryTimeOptions | string) => BigQueryTime;
                  • A TIME data type represents a time, independent of a specific date.

                    Parameter value

                    The time. If a string, this should be in the format the API describes: [H]H:[M]M:[S]S[.DDDDDD]. Otherwise, provide an object.

                    Parameter

                    {string|number} [value.hours] One or two digits (00 - 23).

                    Parameter

                    {string|number} [value.minutes] One or two digits (00 - 59).

                    Parameter

                    {string|number} [value.seconds] One or two digits (00 - 59).

                    Parameter

                    {string|number} [value.fractional] Up to six digits for microsecond precision.

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const bigquery = new BigQuery();
                    const time = bigquery.time('14:00:00'); // 2:00 PM
                    //-
                    // Alternatively, provide an object.
                    //-
                    const time = bigquery.time({
                    hours: 14,
                    minutes: 0,
                    seconds: 0
                    });

                  method timestamp

                  static timestamp: (
                  value: Date | PreciseDate | string | number
                  ) => BigQueryTimestamp;
                  • A timestamp represents an absolute point in time, independent of any time zone or convention such as Daylight Savings Time.

                    The recommended input here is a Date or PreciseDate class. If passing as a string, it should be Timestamp literals: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#timestamp_literals. When passing a number input, it should be epoch seconds in float representation.

                    BigQuery.timestamp

                    Parameter value

                    The time.

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const timestamp = BigQuery.timestamp(new Date());
                  • A timestamp represents an absolute point in time, independent of any time zone or convention such as Daylight Savings Time.

                    The recommended input here is a Date or PreciseDate class. If passing as a string, it should be Timestamp literals: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#timestamp_literals. When passing a number input, it should be epoch seconds in float representation.

                    Parameter value

                    The time.

                    Example 1

                    const {BigQuery} = require('@google-cloud/bigquery');
                    const bigquery = new BigQuery();
                    const timestamp = bigquery.timestamp(new Date());

                  method valueToQueryParameter_

                  static valueToQueryParameter_: (
                  value: any,
                  providedType?: string | ProvidedTypeStruct | ProvidedTypeArray
                  ) => bigquery.IQueryParameter;

                  class BigQueryDate

                  class BigQueryDate {}
                  • Date class for BigQuery.

                  constructor

                  constructor(value: string | BigQueryDateOptions);

                    property value

                    value: string;

                      class BigQueryDatetime

                      class BigQueryDatetime {}
                      • Datetime class for BigQuery.

                      constructor

                      constructor(value: string | BigQueryDatetimeOptions);

                        property value

                        value: string;

                          class BigQueryInt

                          class BigQueryInt extends Number {}
                          • Build a BigQueryInt object. For long integers, a string can be provided.

                            Parameter value

                            The 'INT64' value.

                            Parameter typeCastOptions

                            Configuration to convert values of 'INT64' type to a custom value. Must provide an integerTypeCastFunction to handle conversion.

                            Parameter

                            {function} typeCastOptions.integerTypeCastFunction A custom user provided function to convert value.

                            Parameter

                            {string|string[]} [typeCastOptions.fields] Schema field names to be converted using integerTypeCastFunction.

                            Example 1

                            const {BigQuery} = require('@google-cloud/bigquery');
                            const bigquery = new BigQuery();
                            const anInt = bigquery.int(7);

                          constructor

                          constructor(
                          value: string | number | IntegerTypeCastValue,
                          typeCastOptions?: IntegerTypeCastOptions
                          );

                            property type

                            type: string;

                              property typeCastFunction

                              typeCastFunction?: Function;

                                property value

                                value: string;

                                  method toJSON

                                  toJSON: () => Json;

                                    method valueOf

                                    valueOf: () => any;

                                      class BigQueryTime

                                      class BigQueryTime {}
                                      • Time class for BigQuery.

                                      constructor

                                      constructor(value: string | BigQueryTimeOptions);

                                        property value

                                        value: string;

                                          class BigQueryTimestamp

                                          class BigQueryTimestamp {}
                                          • Timestamp class for BigQuery.

                                            The recommended input here is a Date or PreciseDate class. If passing as a string, it should be Timestamp literals: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#timestamp_literals. When passing a number input, it should be epoch seconds in float representation.

                                          constructor

                                          constructor(value: any);

                                            property value

                                            value: string;

                                              method fromFloatValue_

                                              fromFloatValue_: (value: number) => PreciseDate;

                                                class Dataset

                                                class Dataset extends ServiceObject {}
                                                • Interact with your BigQuery dataset. Create a Dataset instance with BigQuery#createDataset or BigQuery#dataset.

                                                  Parameter bigQuery

                                                  BigQuery instance.

                                                  Parameter id

                                                  The ID of the Dataset.

                                                  Parameter options

                                                  Dataset options.

                                                  Parameter

                                                  {string} [options.projectId] The GCP project ID.

                                                  Parameter

                                                  {string} [options.location] The geographic location of the dataset. Defaults to US.

                                                  Example 1

                                                  const {BigQuery} = require('@google-cloud/bigquery');
                                                  const bigquery = new BigQuery();
                                                  const dataset = bigquery.dataset('institutions');

                                                constructor

                                                constructor(bigQuery: BigQuery, id: string, options?: DatasetOptions);

                                                  property bigQuery

                                                  bigQuery: BigQuery;

                                                    property location

                                                    location?: string;

                                                      property projectId

                                                      projectId: string;

                                                        method createQueryJob

                                                        createQueryJob: {
                                                        (options: string | Query): Promise<JobResponse>;
                                                        (options: string | Query, callback: JobCallback): void;
                                                        };
                                                        • Run a query as a job. No results are immediately returned. Instead, your callback will be executed with a Job object that you must ping for the results. See the Job documentation for explanations of how to check on the status of the job.

                                                          See BigQuery#createQueryJob for full documentation of this method.

                                                          Parameter options

                                                          See BigQuery#createQueryJob for full documentation of this method.

                                                          Parameter callback

                                                          See BigQuery#createQueryJob for full documentation of this method.

                                                          Returns

                                                          {Promise} See BigQuery#createQueryJob for full documentation of this method.

                                                        method createQueryStream

                                                        createQueryStream: (options: Query | string) => Duplex;

                                                        method createRoutine

                                                        createRoutine: {
                                                        (id: string, config: RoutineMetadata): Promise<RoutineResponse>;
                                                        (id: string, config: bigquery.IRoutine, callback: RoutineCallback): void;
                                                        };
                                                        • Create a Routine.

                                                          See Routines: insert API Documentation

                                                          Parameter id

                                                          The routine ID.

                                                          Parameter config

                                                          A [routine resource]https://cloud.google.com/bigquery/docs/reference/rest/v2/routines#Routine.

                                                          Parameter callback

                                                          The callback function.

                                                          Returns

                                                          {Promise}

                                                          Example 1

                                                          const {BigQuery} = require('@google-cloud/bigquery');
                                                          const bigquery = new BigQuery();
                                                          const dataset = bigquery.dataset('my-dataset');
                                                          const id = 'my-routine';
                                                          const config = {
                                                          arguments: [{
                                                          name: 'x',
                                                          dataType: {
                                                          typeKind: 'INT64'
                                                          }
                                                          }],
                                                          definitionBody: 'x * 3',
                                                          routineType: 'SCALAR_FUNCTION',
                                                          returnType: {
                                                          typeKind: 'INT64'
                                                          }
                                                          };
                                                          dataset.createRoutine(id, config, (err, routine, apiResponse) => {
                                                          if (!err) {
                                                          // The routine was created successfully.
                                                          }
                                                          });

                                                          Example 2

                                                          If the callback is omitted a Promise will be returned

                                                          const [routine, apiResponse] = await dataset.createRoutine(id, config);

                                                        method createTable

                                                        createTable: {
                                                        (id: string, options: TableMetadata): Promise<TableResponse>;
                                                        (id: string, options: TableMetadata, callback: TableCallback): void;
                                                        (id: string, callback: TableCallback): void;
                                                        };
                                                        • Create a Table given a tableId or configuration object.

                                                          See Tables: insert API Documentation

                                                          Parameter id

                                                          Table id.

                                                          Parameter options

                                                          See a Table resource.

                                                          Parameter

                                                          {string|object} [options.schema] A comma-separated list of name:type pairs. Valid types are "string", "integer", "float", "boolean", and "timestamp". If the type is omitted, it is assumed to be "string". Example: "name:string, age:integer". Schemas can also be specified as a JSON array of fields, which allows for nested and repeated fields. See a Table resource for more detailed information.

                                                          Parameter callback

                                                          The callback function.

                                                          Parameter

                                                          {?error} callback.err An error returned while making this request

                                                          Parameter

                                                          {Table} callback.table The newly created table.

                                                          Parameter

                                                          {object} callback.apiResponse The full API response.

                                                          Returns

                                                          {Promise}

                                                          Example 1

                                                          const {BigQuery} = require('@google-cloud/bigquery');
                                                          const bigquery = new BigQuery();
                                                          const dataset = bigquery.dataset('institutions');
                                                          const tableId = 'institution_data';
                                                          const options = {
                                                          // From the data.gov CSV dataset (http://goo.gl/kSE7z6):
                                                          schema: 'UNITID,INSTNM,ADDR,CITY,STABBR,ZIP,FIPS,OBEREG,CHFNM,...'
                                                          };
                                                          dataset.createTable(tableId, options, (err, table, apiResponse) => {});
                                                          //-
                                                          // If the callback is omitted, we'll return a Promise.
                                                          //-
                                                          dataset.createTable(tableId, options).then((data) => {
                                                          const table = data[0];
                                                          const apiResponse = data[1];
                                                          });

                                                        method delete

                                                        delete: {
                                                        (options?: DatasetDeleteOptions): Promise<[Metadata]>;
                                                        (options: DatasetDeleteOptions, callback: DeleteCallback): void;
                                                        (callback: DeleteCallback): void;
                                                        };
                                                        • Delete the dataset.

                                                          See Datasets: delete API Documentation

                                                          Parameter options

                                                          The configuration object.

                                                          Parameter

                                                          {boolean} [options.force=false] Force delete dataset and all tables.

                                                          Parameter callback

                                                          The callback function.

                                                          Parameter

                                                          {?error} callback.err An error returned while making this request

                                                          Parameter

                                                          {object} callback.apiResponse The full API response.

                                                          Returns

                                                          {Promise}

                                                          Example 1

                                                          const {BigQuery} = require('@google-cloud/bigquery');
                                                          const bigquery = new BigQuery();
                                                          const dataset = bigquery.dataset('institutions');
                                                          //-
                                                          // Delete the dataset, only if it does not have any tables.
                                                          //-
                                                          dataset.delete((err, apiResponse) => {});
                                                          //-
                                                          // Delete the dataset and any tables it contains.
                                                          //-
                                                          dataset.delete({ force: true }, (err, apiResponse) => {});
                                                          //-
                                                          // If the callback is omitted, we'll return a Promise.
                                                          //-
                                                          dataset.delete().then((data) => {
                                                          const apiResponse = data[0];
                                                          });

                                                        method getModels

                                                        getModels: {
                                                        (options?: GetModelsOptions): Promise<GetModelsResponse>;
                                                        (options: GetModelsOptions, callback: GetModelsCallback): void;
                                                        (callback: GetModelsCallback): void;
                                                        };
                                                        • Get a list of Model resources.

                                                          See Models: list API Documentation

                                                          Parameter options

                                                          Configuration object.

                                                          Parameter

                                                          {boolean} [options.autoPaginate=true] Have pagination handled automatically.

                                                          Parameter

                                                          {number} [options.maxApiCalls] Maximum number of API calls to make.

                                                          Parameter

                                                          {number} [options.maxResults] Maximum number of results to return.

                                                          Parameter

                                                          {string} [options.pageToken] Token returned from a previous call, to request the next page of results.

                                                          Parameter callback

                                                          The callback function.

                                                          Parameter

                                                          {?error} callback.err An error returned while making this request

                                                          Parameter

                                                          {Model[]} callback.models The list of models from your Dataset.

                                                          Parameter

                                                          {GetModelsOptions} callback.nextQuery If autoPaginate is set to true, this will be a prepared query for the next page of results.

                                                          Parameter

                                                          {object} callback.apiResponse The full API response.

                                                          Returns

                                                          {Promise}

                                                          Example 1

                                                          const {BigQuery} = require('@google-cloud/bigquery');
                                                          const bigquery = new BigQuery();
                                                          const dataset = bigquery.dataset('institutions');
                                                          dataset.getModels((err, models) => {
                                                          // models is an array of `Model` objects.
                                                          });

                                                          Example 2

                                                          To control how many API requests are made and page through the results manually, set autoPaginate to false.

                                                          function manualPaginationCallback(err, models, nextQuery, apiResponse) {
                                                          if (nextQuery) {
                                                          // More results exist.
                                                          dataset.getModels(nextQuery, manualPaginationCallback);
                                                          }
                                                          }
                                                          dataset.getModels({
                                                          autoPaginate: false
                                                          }, manualPaginationCallback);

                                                          Example 3

                                                          If the callback is omitted, we'll return a Promise.

                                                          dataset.getModels().then((data) => {
                                                          const models = data[0];
                                                          });

                                                        method getModelsStream

                                                        getModelsStream: (options?: GetModelsOptions) => ResourceStream<Model>;

                                                          method getRoutines

                                                          getRoutines: {
                                                          (options?: GetRoutinesOptions): Promise<GetRoutinesResponse>;
                                                          (options: GetRoutinesOptions, callback: GetRoutinesCallback): void;
                                                          (callback: GetRoutinesCallback): void;
                                                          };
                                                          • Get a list of routines.

                                                            See Routines: list API Documentation

                                                            Parameter options

                                                            Request options.

                                                            Parameter

                                                            {boolean} [options.autoPaginate=true] Have pagination handled automatically.

                                                            Parameter

                                                            {number} [options.maxApiCalls] Maximum number of API calls to make.

                                                            Parameter

                                                            {number} [options.maxResults] Maximum number of results to return.

                                                            Parameter

                                                            {string} [options.pageToken] Token returned from a previous call, to request the next page of results.

                                                            Parameter callback

                                                            The callback function.

                                                            Parameter

                                                            {?error} callback.err An error returned while making this request

                                                            Parameter

                                                            {Routine[]} callback.routines The list of models from your Dataset.

                                                            Parameter

                                                            {GetRoutinesOptions} callback.nextQuery If autoPaginate is set to true, this will be a prepared query for the next page of results.

                                                            Parameter

                                                            {object} callback.apiResponse The full API response.

                                                            Returns

                                                            {Promise}

                                                            Example 1

                                                            const {BigQuery} = require('@google-cloud/bigquery');
                                                            const bigquery = new BigQuery();
                                                            const dataset = bigquery.dataset('institutions');
                                                            dataset.getRoutines((err, routines) => {
                                                            // routines is an array of `Routine` objects.
                                                            });

                                                            Example 2

                                                            To control how many API requests are made and page through the results manually, set autoPaginate to false.

                                                            function manualPaginationCallback(err, routines, nextQuery, apiResponse) {
                                                            if (nextQuery) {
                                                            // More results exist.
                                                            dataset.getRoutines(nextQuery, manualPaginationCallback);
                                                            }
                                                            }
                                                            dataset.getRoutines({
                                                            autoPaginate: false
                                                            }, manualPaginationCallback);

                                                            Example 3

                                                            If the callback is omitted a Promise will be returned

                                                            const [routines] = await dataset.getRoutines();

                                                          method getRoutinesStream

                                                          getRoutinesStream: (options?: GetRoutinesOptions) => ResourceStream<Routine>;

                                                            method getTables

                                                            getTables: {
                                                            (options?: GetTablesOptions): Promise<GetTablesResponse>;
                                                            (options: GetTablesOptions, callback: GetTablesCallback): void;
                                                            (callback: GetTablesCallback): void;
                                                            };
                                                            • Get a list of Table resources.

                                                              See Tables: list API Documentation

                                                              Parameter options

                                                              Configuration object.

                                                              Parameter

                                                              {boolean} [options.autoPaginate=true] Have pagination handled automatically.

                                                              Parameter

                                                              {number} [options.maxApiCalls] Maximum number of API calls to make.

                                                              Parameter

                                                              {number} [options.maxResults] Maximum number of results to return.

                                                              Parameter

                                                              {string} [options.pageToken] Token returned from a previous call, to request the next page of results.

                                                              Parameter callback

                                                              The callback function.

                                                              Parameter

                                                              {?error} callback.err An error returned while making this request

                                                              Parameter

                                                              {Table[]} callback.tables The list of tables from your Dataset.

                                                              Parameter

                                                              {GetTablesOptions} callback.nextQuery If autoPaginate is set to true, this will be a prepared query for the next page of results.

                                                              Parameter

                                                              {object} callback.apiResponse The full API response.

                                                              Returns

                                                              {Promise}

                                                              Example 1

                                                              const {BigQuery} = require('@google-cloud/bigquery');
                                                              const bigquery = new BigQuery();
                                                              const dataset = bigquery.dataset('institutions');
                                                              dataset.getTables((err, tables) => {
                                                              // tables is an array of `Table` objects.
                                                              });
                                                              //-
                                                              // To control how many API requests are made and page through the results
                                                              // manually, set `autoPaginate` to `false`.
                                                              //-
                                                              function manualPaginationCallback(err, tables, nextQuery, apiResponse) {
                                                              if (nextQuery) {
                                                              // More results exist.
                                                              dataset.getTables(nextQuery, manualPaginationCallback);
                                                              }
                                                              }
                                                              dataset.getTables({
                                                              autoPaginate: false
                                                              }, manualPaginationCallback);
                                                              //-
                                                              // If the callback is omitted, we'll return a Promise.
                                                              //-
                                                              dataset.getTables().then((data) => {
                                                              const tables = data[0];
                                                              });

                                                            method getTablesStream

                                                            getTablesStream: (options?: GetTablesOptions) => ResourceStream<Table>;

                                                              method model

                                                              model: (id: string) => Model;
                                                              • Create a Model object.

                                                                Parameter id

                                                                The ID of the model. {Model}

                                                                Throws

                                                                {TypeError} if model ID is missing.

                                                                Example 1

                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                const bigquery = new BigQuery();
                                                                const dataset = bigquery.dataset('institutions');
                                                                const model = dataset.model('my-model');

                                                              method query

                                                              query: {
                                                              (options: Query): Promise<QueryRowsResponse>;
                                                              (options: string): Promise<QueryRowsResponse>;
                                                              (options: Query, callback: SimpleQueryRowsCallback): void;
                                                              (options: string, callback: SimpleQueryRowsCallback): void;
                                                              };
                                                              • Run a query scoped to your dataset.

                                                                See BigQuery#query for full documentation of this method.

                                                                Parameter options

                                                                See BigQuery#query for full documentation of this method.

                                                                Parameter callback

                                                                See BigQuery#query for full documentation of this method.

                                                                Returns

                                                                {Promise} See BigQuery#query for full documentation of this method.

                                                              method routine

                                                              routine: (id: string) => Routine;
                                                              • Create a Routine object.

                                                                Parameter id

                                                                The ID of the routine.

                                                                Returns

                                                                {Routine}

                                                                Throws

                                                                {TypeError} if routine ID is missing.

                                                                Example 1

                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                const bigquery = new BigQuery();
                                                                const dataset = bigquery.dataset('institutions');
                                                                const routine = dataset.routine('my_routine');

                                                              method table

                                                              table: (id: string, options?: TableOptions) => Table;
                                                              • Create a Table object.

                                                                Parameter id

                                                                The ID of the table.

                                                                Parameter options

                                                                Table options.

                                                                Parameter

                                                                {string} [options.location] The geographic location of the table, by default this value is inherited from the dataset. This can be used to configure the location of all jobs created through a table instance. It cannot be used to set the actual location of the table. This value will be superseded by any API responses containing location data for the table. {Table}

                                                                Throws

                                                                {TypeError} if table ID is missing.

                                                                Example 1

                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                const bigquery = new BigQuery();
                                                                const dataset = bigquery.dataset('institutions');
                                                                const institutions = dataset.table('institution_data');

                                                              class Geography

                                                              class Geography {}
                                                              • Geography class for BigQuery.

                                                              constructor

                                                              constructor(value: string);

                                                                property value

                                                                value: string;

                                                                  class Job

                                                                  class Job extends Operation {}
                                                                  • Job objects are returned from various places in the BigQuery API:

                                                                    - BigQuery#getJobs - BigQuery#job - BigQuery#query - BigQuery#createJob - Table#copy - Table#createWriteStream - Table#extract - Table#load

                                                                    They can be used to check the status of a running job or fetching the results of a previously-executed one.

                                                                    Parameter bigQuery

                                                                    BigQuery instance.

                                                                    Parameter id

                                                                    The ID of the job.

                                                                    Parameter options

                                                                    Configuration object.

                                                                    Parameter

                                                                    {string} [options.location] The geographic location of the job. Required except for US and EU.

                                                                    Example 1

                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                    const bigquery = new BigQuery();
                                                                    const job = bigquery.job('job-id');
                                                                    //-
                                                                    // All jobs are event emitters. The status of each job is polled
                                                                    // continuously, starting only after you register a "complete" listener.
                                                                    //-
                                                                    job.on('complete', (metadata) => {
                                                                    // The job is complete.
                                                                    });
                                                                    //-
                                                                    // Be sure to register an error handler as well to catch any issues which
                                                                    // impeded the job.
                                                                    //-
                                                                    job.on('error', (err) => {
                                                                    // An error occurred during the job.
                                                                    });
                                                                    //-
                                                                    // To force the Job object to stop polling for updates, simply remove any
                                                                    // "complete" listeners you've registered.
                                                                    //
                                                                    // The easiest way to do this is with `removeAllListeners()`.
                                                                    //-
                                                                    job.removeAllListeners();

                                                                  constructor

                                                                  constructor(bigQuery: BigQuery, id: string, options?: JobOptions);

                                                                    property bigQuery

                                                                    bigQuery: BigQuery;

                                                                      property location

                                                                      location?: string;

                                                                        property projectId

                                                                        projectId?: string;

                                                                          method cancel

                                                                          cancel: { (): Promise<CancelResponse>; (callback: CancelCallback): void };
                                                                          • Cancel a job. Use Job#getMetadata to see if the cancel completes successfully. See an example implementation below.

                                                                            See Jobs: get API Documentation

                                                                            Parameter callback

                                                                            The callback function.

                                                                            Parameter

                                                                            {?error} callback.err An error returned while making this request.

                                                                            Parameter

                                                                            {object} callback.apiResponse The full API response.

                                                                            Returns

                                                                            {Promise}

                                                                            Example 1

                                                                            const {BigQuery} = require('@google-cloud/bigquery');
                                                                            const bigquery = new BigQuery();
                                                                            const job = bigquery.job('job-id');
                                                                            job.cancel((err, apiResponse) =>{
                                                                            // Check to see if the job completes successfully.
                                                                            job.on('error', (err) => {});
                                                                            job.on('complete', (metadata) => {});
                                                                            });
                                                                            //-
                                                                            // If the callback is omitted, we'll return a Promise.
                                                                            //-
                                                                            job.cancel().then((data) => {
                                                                            const apiResponse = data[0];
                                                                            });

                                                                          method getQueryResults

                                                                          getQueryResults: {
                                                                          (options?: QueryResultsOptions): Promise<QueryRowsResponse>;
                                                                          (options: QueryResultsOptions, callback: QueryRowsCallback): void;
                                                                          (callback: QueryRowsCallback): void;
                                                                          };
                                                                          • Get the results of a job.

                                                                            See Jobs: getQueryResults API Documentation

                                                                            Parameter options

                                                                            Configuration object.

                                                                            Parameter

                                                                            {boolean} [options.autoPaginate=true] Have pagination handled automatically.

                                                                            Parameter

                                                                            {number} [options.maxApiCalls] Maximum number of API calls to make.

                                                                            Parameter

                                                                            {number} [options.maxResults] Maximum number of results to read.

                                                                            Parameter

                                                                            {string} [options.pageToken] Page token, returned by a previous call, to request the next page of results. Note: This is automatically added to the nextQuery argument of your callback.

                                                                            Parameter

                                                                            {number} [options.startIndex] Zero-based index of the starting row.

                                                                            Parameter

                                                                            {number} [options.timeoutMs] How long to wait for the query to complete, in milliseconds, before returning. Default is 10 seconds. If the timeout passes before the job completes, an error will be returned and the 'jobComplete' field in the response will be false.

                                                                            Parameter

                                                                            {boolean|IntegerTypeCastOptions} [options.wrapIntegers=false] Wrap values of 'INT64' type in BigQueryInt objects. If a boolean, this will wrap values in BigQueryInt objects. If an object, this will return a value returned by wrapIntegers.integerTypeCastFunction.

                                                                            Parameter callback

                                                                            The callback function. If autoPaginate is set to false a ManualQueryResultsCallback should be used.

                                                                            Returns

                                                                            {Promise}

                                                                            Example 1

                                                                            const {BigQuery} = require('@google-cloud/bigquery');
                                                                            const bigquery = new BigQuery();
                                                                            const job = bigquery.job('job-id');
                                                                            //-
                                                                            // Get all of the results of a query.
                                                                            //-
                                                                            job.getQueryResults((err, rows) => {
                                                                            if (!err) {
                                                                            // rows is an array of results.
                                                                            }
                                                                            });
                                                                            //-
                                                                            // Customize the results you want to fetch.
                                                                            //-
                                                                            job.getQueryResults({
                                                                            maxResults: 100
                                                                            }, (err, rows) => {});
                                                                            //-
                                                                            // To control how many API requests are made and page through the results
                                                                            // manually, set `autoPaginate` to `false`.
                                                                            //-
                                                                            function manualPaginationCallback(err, rows, nextQuery, apiResponse) {
                                                                            if (nextQuery) {
                                                                            // More results exist.
                                                                            job.getQueryResults(nextQuery, manualPaginationCallback);
                                                                            }
                                                                            }
                                                                            job.getQueryResults({
                                                                            autoPaginate: false
                                                                            }, manualPaginationCallback);
                                                                            //-
                                                                            // If the callback is omitted, we'll return a Promise.
                                                                            //-
                                                                            job.getQueryResults().then((data) => {
                                                                            const rows = data[0];
                                                                            });

                                                                          method getQueryResultsAsStream_

                                                                          getQueryResultsAsStream_: (
                                                                          options: QueryResultsOptions,
                                                                          callback: QueryRowsCallback
                                                                          ) => void;
                                                                          • This method will be called by getQueryResultsStream(). It is required to properly set the autoPaginate option value.

                                                                          method getQueryResultsStream

                                                                          getQueryResultsStream: (options?: QueryResultsOptions) => ResourceStream<any>;

                                                                            method poll_

                                                                            poll_: (callback: MetadataCallback) => void;
                                                                            • Poll for a status update. Execute the callback:

                                                                              - callback(err): Job failed - callback(): Job incomplete - callback(null, metadata): Job complete

                                                                              Parameter callback

                                                                            class Model

                                                                            class Model extends ServiceObject {}
                                                                            • Model objects are returned by methods such as Dataset#model and Dataset#getModels.

                                                                              Parameter dataset

                                                                              Dataset instance.

                                                                              Parameter id

                                                                              The ID of the model.

                                                                              Example 1

                                                                              const {BigQuery} = require('@google-cloud/bigquery');
                                                                              const bigquery = new BigQuery();
                                                                              const dataset = bigquery.dataset('my-dataset');
                                                                              const model = dataset.model('my-model');

                                                                            constructor

                                                                            constructor(dataset: Dataset, id: string);

                                                                              property bigQuery

                                                                              bigQuery: BigQuery;

                                                                                property dataset

                                                                                dataset: Dataset;

                                                                                  method createExtractJob

                                                                                  createExtractJob: {
                                                                                  (
                                                                                  destination: string | File,
                                                                                  options?: CreateExtractJobOptions
                                                                                  ): Promise<JobResponse>;
                                                                                  (
                                                                                  destination: string | File,
                                                                                  options: CreateExtractJobOptions,
                                                                                  callback: JobCallback
                                                                                  ): void;
                                                                                  (destination: string | File, callback: JobCallback): void;
                                                                                  };
                                                                                  • Export model to Cloud Storage.

                                                                                    See Jobs: insert API Documentation

                                                                                    Parameter destination

                                                                                    Where the model should be exported to. A string or object.

                                                                                    Parameter options

                                                                                    The configuration object. For all extract job options, see [CreateExtractJobOptions]https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationExtract.

                                                                                    Parameter

                                                                                    {string} [options.format] The format to export the data in. Allowed options are "ML_TF_SAVED_MODEL" or "ML_XGBOOST_BOOSTER". Default: "ML_TF_SAVED_MODEL".

                                                                                    Parameter

                                                                                    {string} [options.jobId] Custom job id.

                                                                                    Parameter

                                                                                    {string} [options.jobPrefix] Prefix to apply to the job id.

                                                                                    Parameter callback

                                                                                    The callback function.

                                                                                    Parameter

                                                                                    {?error} callback.err An error returned while making this request.

                                                                                    Parameter

                                                                                    {Job} callback.job The job used to export the model.

                                                                                    Parameter

                                                                                    {object} callback.apiResponse The full API response.

                                                                                    Returns

                                                                                    {Promise}

                                                                                    Throws

                                                                                    {Error} If a destination isn't a string or File object.

                                                                                    Example 1

                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                    const bigquery = new BigQuery();
                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                    const model = dataset.model('my-model');
                                                                                    const extractedModel = 'gs://my-bucket/extracted-model';
                                                                                    function callback(err, job, apiResponse) {
                                                                                    // `job` is a Job object that can be used to check the status of the
                                                                                    // request.
                                                                                    }
                                                                                    //-
                                                                                    // To use the default options, just pass a string or a {@link
                                                                                    https://googleapis.dev/nodejs/storage/latest/File.html File}
                                                                                    object.
                                                                                    //
                                                                                    // Note: The default format is 'ML_TF_SAVED_MODEL'.
                                                                                    //-
                                                                                    model.createExtractJob(extractedModel, callback);
                                                                                    //-
                                                                                    // If you need more customization, pass an `options` object.
                                                                                    //-
                                                                                    const options = {
                                                                                    format: 'ML_TF_SAVED_MODEL',
                                                                                    jobId: '123abc'
                                                                                    };
                                                                                    model.createExtractJob(extractedModel, options, callback);
                                                                                    //-
                                                                                    // If the callback is omitted, we'll return a Promise.
                                                                                    //-
                                                                                    model.createExtractJob(extractedModel, options).then((data) => {
                                                                                    const job = data[0];
                                                                                    const apiResponse = data[1];
                                                                                    });

                                                                                  method extract

                                                                                  extract: {
                                                                                  (
                                                                                  destination: string | File,
                                                                                  options?: CreateExtractJobOptions
                                                                                  ): Promise<JobMetadataResponse>;
                                                                                  (
                                                                                  destination: string | File,
                                                                                  options: CreateExtractJobOptions,
                                                                                  callback?: JobMetadataCallback
                                                                                  ): void;
                                                                                  (destination: string | File, callback?: JobMetadataCallback): void;
                                                                                  };
                                                                                  • Export model to Cloud Storage.

                                                                                    Parameter destination

                                                                                    Where the model should be exported to. A string or object.

                                                                                    Parameter options

                                                                                    The configuration object. For all extract job options, see [CreateExtractJobOptions]https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationExtract.

                                                                                    Parameter

                                                                                    {string} [options.format] The format to export the data in. Allowed options are "ML_TF_SAVED_MODEL" or "ML_XGBOOST_BOOSTER". Default: "ML_TF_SAVED_MODEL".

                                                                                    Parameter

                                                                                    {string} [options.jobId] Custom id for the underlying job.

                                                                                    Parameter

                                                                                    {string} [options.jobPrefix] Prefix to apply to the underlying job id.

                                                                                    Parameter callback

                                                                                    The callback function.

                                                                                    Parameter

                                                                                    {?error} callback.err An error returned while making this request

                                                                                    Parameter

                                                                                    {object} callback.apiResponse The full API response.

                                                                                    Returns

                                                                                    {Promise}

                                                                                    Throws

                                                                                    {Error} If destination isn't a string or File object.

                                                                                    Example 1

                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                    const bigquery = new BigQuery();
                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                    const model = dataset.model('my-model');
                                                                                    const extractedModel = 'gs://my-bucket/extracted-model';
                                                                                    //-
                                                                                    function callback(err, job, apiResponse) {
                                                                                    // `job` is a Job object that can be used to check the status of the
                                                                                    // request.
                                                                                    }
                                                                                    //-
                                                                                    // To use the default options, just pass a string or a {@link
                                                                                    https://googleapis.dev/nodejs/storage/latest/File.html File}
                                                                                    object.
                                                                                    //
                                                                                    // Note: The default format is 'ML_TF_SAVED_MODEL'.
                                                                                    //-
                                                                                    model.createExtractJob(extractedModel, callback);
                                                                                    //-
                                                                                    // If you need more customization, pass an `options` object.
                                                                                    //-
                                                                                    const options = {
                                                                                    format: 'ML_TF_SAVED_MODEL',
                                                                                    jobId: '123abc'
                                                                                    };
                                                                                    model.createExtractJob(extractedModel, options, callback);
                                                                                    //-
                                                                                    // If the callback is omitted, we'll return a Promise.
                                                                                    //-
                                                                                    model.createExtractJob(extractedModel, options).then((data) => {
                                                                                    const job = data[0];
                                                                                    const apiResponse = data[1];
                                                                                    });

                                                                                  class Routine

                                                                                  class Routine extends ServiceObject {}
                                                                                  • Routine objects are returned by methods such as Dataset#routine, Dataset#createRoutine, and Dataset#getRoutines.

                                                                                    Parameter dataset

                                                                                    Dataset instance.

                                                                                    Parameter id

                                                                                    The ID of the routine.

                                                                                    Example 1

                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                    const bigquery = new BigQuery();
                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                    const routine = dataset.routine('my_routine');

                                                                                  constructor

                                                                                  constructor(dataset: Dataset, id: string);

                                                                                    method setMetadata

                                                                                    setMetadata: {
                                                                                    (metadata: RoutineMetadata): Promise<SetMetadataResponse>;
                                                                                    (metadata: bigquery.IRoutine, callback: ResponseCallback): void;
                                                                                    };

                                                                                      class RowBatch

                                                                                      class RowBatch {}
                                                                                      • Call used to help batch rows.

                                                                                        Parameter options

                                                                                        The batching options.

                                                                                      constructor

                                                                                      constructor(options: RowBatchOptions);

                                                                                        property batchOptions

                                                                                        batchOptions: RowBatchOptions;

                                                                                          property bytes

                                                                                          bytes: number;

                                                                                            property callbacks

                                                                                            callbacks: InsertRowsCallback[];

                                                                                              property created

                                                                                              created: number;

                                                                                                property rows

                                                                                                rows: any[];

                                                                                                  method add

                                                                                                  add: (row: RowMetadata, callback?: InsertRowsCallback) => void;
                                                                                                  • Adds a row to the current batch.

                                                                                                    Parameter row

                                                                                                    The row to insert.

                                                                                                    Parameter callback

                                                                                                    The callback function.

                                                                                                  method canFit

                                                                                                  canFit: (row: RowMetadata) => boolean;
                                                                                                  • Indicates if a given row can fit in the batch.

                                                                                                    Parameter row

                                                                                                    The row in question.

                                                                                                    Returns

                                                                                                    {boolean}

                                                                                                  method isAtMax

                                                                                                  isAtMax: () => boolean;
                                                                                                  • Checks to see if this batch is at the maximum allowed payload size.

                                                                                                    Returns

                                                                                                    {boolean}

                                                                                                  method isFull

                                                                                                  isFull: () => boolean;
                                                                                                  • Indicates if the batch is at capacity.

                                                                                                    Returns

                                                                                                    {boolean}

                                                                                                  class RowQueue

                                                                                                  class RowQueue {}
                                                                                                  • Standard row queue used for inserting rows.

                                                                                                    Parameter table

                                                                                                    The table.

                                                                                                    Parameter dup

                                                                                                    Row stream.

                                                                                                    Parameter options

                                                                                                    Insert and batch options.

                                                                                                  constructor

                                                                                                  constructor(table: Table, dup: Stream, options?: InsertStreamOptions);

                                                                                                    property batch

                                                                                                    batch: RowBatch;

                                                                                                      property batchOptions

                                                                                                      batchOptions?: RowBatchOptions;

                                                                                                        property inFlight

                                                                                                        inFlight: boolean;

                                                                                                          property insertRowsOptions

                                                                                                          insertRowsOptions: InsertRowsOptions;

                                                                                                            property pending

                                                                                                            pending?: number;

                                                                                                              property stream

                                                                                                              stream: Stream;

                                                                                                                property table

                                                                                                                table: Table;

                                                                                                                  method add

                                                                                                                  add: (row: RowMetadata, callback: InsertRowsCallback) => void;
                                                                                                                  • Adds a row to the queue.

                                                                                                                    Parameter row

                                                                                                                    The row to insert.

                                                                                                                    Parameter callback

                                                                                                                    The insert callback.

                                                                                                                  method getOptionDefaults

                                                                                                                  getOptionDefaults: () => RowBatchOptions;

                                                                                                                    method insert

                                                                                                                    insert: (callback?: InsertRowsCallback) => void;
                                                                                                                    • Cancels any pending inserts and calls _insert immediately.

                                                                                                                    method setOptions

                                                                                                                    setOptions: (options?: RowBatchOptions) => void;
                                                                                                                    • Sets the batching options.

                                                                                                                      Parameter options

                                                                                                                      The batching options.

                                                                                                                    class Table

                                                                                                                    class Table extends ServiceObject {}
                                                                                                                    • Table objects are returned by methods such as Dataset#table, Dataset#createTable, and Dataset#getTables.

                                                                                                                      Parameter dataset

                                                                                                                      Dataset instance.

                                                                                                                      Parameter id

                                                                                                                      The ID of the table.

                                                                                                                      Parameter options

                                                                                                                      Table options.

                                                                                                                      Parameter

                                                                                                                      {string} [options.location] The geographic location of the table, by default this value is inherited from the dataset. This can be used to configure the location of all jobs created through a table instance. It cannot be used to set the actual location of the table. This value will be superseded by any API responses containing location data for the table.

                                                                                                                      Example 1

                                                                                                                      const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                      const bigquery = new BigQuery();
                                                                                                                      const dataset = bigquery.dataset('my-dataset');
                                                                                                                      const table = dataset.table('my-table');

                                                                                                                    constructor

                                                                                                                    constructor(dataset: Dataset, id: string, options?: TableOptions);

                                                                                                                      property bigQuery

                                                                                                                      bigQuery: BigQuery;

                                                                                                                        property dataset

                                                                                                                        dataset: Dataset;

                                                                                                                          property location

                                                                                                                          location?: string;

                                                                                                                            property rowQueue

                                                                                                                            rowQueue?: RowQueue;

                                                                                                                              method copy

                                                                                                                              copy: {
                                                                                                                              (
                                                                                                                              destination: Table,
                                                                                                                              metadata?: CopyTableMetadata
                                                                                                                              ): Promise<JobMetadataResponse>;
                                                                                                                              (
                                                                                                                              destination: Table,
                                                                                                                              metadata: CopyTableMetadata,
                                                                                                                              callback: JobMetadataCallback
                                                                                                                              ): void;
                                                                                                                              (destination: Table, callback: JobMetadataCallback): void;
                                                                                                                              };
                                                                                                                              • Copy data from one table to another, optionally creating that table.

                                                                                                                                Parameter destination

                                                                                                                                The destination table.

                                                                                                                                Parameter metadata

                                                                                                                                Metadata to set with the copy operation. The metadata object should be in the format of a `JobConfigurationTableCopy` object. object.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobId] Custom id for the underlying job.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobPrefix] Prefix to apply to the underlying job id.

                                                                                                                                Parameter callback

                                                                                                                                The callback function.

                                                                                                                                Parameter

                                                                                                                                {?error} callback.err An error returned while making this request

                                                                                                                                Parameter

                                                                                                                                {object} callback.apiResponse The full API response.

                                                                                                                                Returns

                                                                                                                                {Promise}

                                                                                                                                Throws

                                                                                                                                {Error} If a destination other than a Table object is provided.

                                                                                                                                Example 1

                                                                                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                const bigquery = new BigQuery();
                                                                                                                                const dataset = bigquery.dataset('my-dataset');
                                                                                                                                const table = dataset.table('my-table');
                                                                                                                                const yourTable = dataset.table('your-table');
                                                                                                                                table.copy(yourTable, (err, apiResponse) => {});
                                                                                                                                //-
                                                                                                                                // See https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy
                                                                                                                                // for all available options.
                                                                                                                                //-
                                                                                                                                const metadata = {
                                                                                                                                createDisposition: 'CREATE_NEVER',
                                                                                                                                writeDisposition: 'WRITE_TRUNCATE'
                                                                                                                                };
                                                                                                                                table.copy(yourTable, metadata, (err, apiResponse) => {});
                                                                                                                                //-
                                                                                                                                // If the callback is omitted, we'll return a Promise.
                                                                                                                                //-
                                                                                                                                table.copy(yourTable, metadata).then((data) => {
                                                                                                                                const apiResponse = data[0];
                                                                                                                                });

                                                                                                                              method copyFrom

                                                                                                                              copyFrom: {
                                                                                                                              (
                                                                                                                              sourceTables: Table | Table[],
                                                                                                                              metadata?: CopyTableMetadata
                                                                                                                              ): Promise<JobMetadataResponse>;
                                                                                                                              (
                                                                                                                              sourceTables: Table | Table[],
                                                                                                                              metadata: CopyTableMetadata,
                                                                                                                              callback: JobMetadataCallback
                                                                                                                              ): void;
                                                                                                                              (sourceTables: Table | Table[], callback: JobMetadataCallback): void;
                                                                                                                              };
                                                                                                                              • Copy data from multiple tables into this table.

                                                                                                                                Parameter sourceTables

                                                                                                                                The source table(s) to copy data from.

                                                                                                                                Parameter metadata

                                                                                                                                Metadata to set with the copy operation. The metadata object should be in the format of a `JobConfigurationTableCopy` object.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobId] Custom id for the underlying job.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobPrefix] Prefix to apply to the underlying job id.

                                                                                                                                Parameter callback

                                                                                                                                The callback function.

                                                                                                                                Parameter

                                                                                                                                {?error} callback.err An error returned while making this request

                                                                                                                                Parameter

                                                                                                                                {object} callback.apiResponse The full API response.

                                                                                                                                Returns

                                                                                                                                {Promise}

                                                                                                                                Throws

                                                                                                                                {Error} If a source other than a Table object is provided.

                                                                                                                                Example 1

                                                                                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                const bigquery = new BigQuery();
                                                                                                                                const dataset = bigquery.dataset('my-dataset');
                                                                                                                                const table = dataset.table('my-table');
                                                                                                                                const sourceTables = [
                                                                                                                                dataset.table('your-table'),
                                                                                                                                dataset.table('your-second-table')
                                                                                                                                ];
                                                                                                                                table.copyFrom(sourceTables, (err, apiResponse) => {});
                                                                                                                                //-
                                                                                                                                // See https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy
                                                                                                                                // for all available options.
                                                                                                                                //-
                                                                                                                                const metadata = {
                                                                                                                                createDisposition: 'CREATE_NEVER',
                                                                                                                                writeDisposition: 'WRITE_TRUNCATE'
                                                                                                                                };
                                                                                                                                table.copyFrom(sourceTables, metadata, (err, apiResponse) => {});
                                                                                                                                //-
                                                                                                                                // If the callback is omitted, we'll return a Promise.
                                                                                                                                //-
                                                                                                                                table.copyFrom(sourceTables, metadata).then((data) => {
                                                                                                                                const apiResponse = data[0];
                                                                                                                                });

                                                                                                                              method createCopyFromJob

                                                                                                                              createCopyFromJob: {
                                                                                                                              (
                                                                                                                              source: Table | Table[],
                                                                                                                              metadata?: CopyTableMetadata
                                                                                                                              ): Promise<JobResponse>;
                                                                                                                              (
                                                                                                                              source: Table | Table[],
                                                                                                                              metadata: CopyTableMetadata,
                                                                                                                              callback: JobCallback
                                                                                                                              ): void;
                                                                                                                              (source: Table | Table[], callback: JobCallback): void;
                                                                                                                              };
                                                                                                                              • Copy data from multiple tables into this table.

                                                                                                                                See Jobs: insert API Documentation

                                                                                                                                Parameter sourceTables

                                                                                                                                The source table(s) to copy data from.

                                                                                                                                Parameter metadata

                                                                                                                                Metadata to set with the copy operation. The metadata object should be in the format of a `JobConfigurationTableCopy` object.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobId] Custom job id.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobPrefix] Prefix to apply to the job id.

                                                                                                                                Parameter callback

                                                                                                                                The callback function.

                                                                                                                                Parameter

                                                                                                                                {?error} callback.err An error returned while making this request

                                                                                                                                Parameter

                                                                                                                                {Job} callback.job The job used to copy your table.

                                                                                                                                Parameter

                                                                                                                                {object} callback.apiResponse The full API response.

                                                                                                                                Returns

                                                                                                                                {Promise}

                                                                                                                                Throws

                                                                                                                                {Error} If a source other than a Table object is provided.

                                                                                                                                Example 1

                                                                                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                const bigquery = new BigQuery();
                                                                                                                                const dataset = bigquery.dataset('my-dataset');
                                                                                                                                const table = dataset.table('my-table');
                                                                                                                                const sourceTables = [
                                                                                                                                dataset.table('your-table'),
                                                                                                                                dataset.table('your-second-table')
                                                                                                                                ];
                                                                                                                                const callback = (err, job, apiResponse) => {
                                                                                                                                // `job` is a Job object that can be used to check the status of the
                                                                                                                                // request.
                                                                                                                                };
                                                                                                                                table.createCopyFromJob(sourceTables, callback);
                                                                                                                                //-
                                                                                                                                // See https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy
                                                                                                                                // for all available options.
                                                                                                                                //-
                                                                                                                                const metadata = {
                                                                                                                                createDisposition: 'CREATE_NEVER',
                                                                                                                                writeDisposition: 'WRITE_TRUNCATE'
                                                                                                                                };
                                                                                                                                table.createCopyFromJob(sourceTables, metadata, callback);
                                                                                                                                //-
                                                                                                                                // If the callback is omitted, we'll return a Promise.
                                                                                                                                //-
                                                                                                                                table.createCopyFromJob(sourceTables, metadata).then((data) => {
                                                                                                                                const job = data[0];
                                                                                                                                const apiResponse = data[1];
                                                                                                                                });

                                                                                                                              method createCopyJob

                                                                                                                              createCopyJob: {
                                                                                                                              (destination: Table, metadata?: CreateCopyJobMetadata): Promise<JobResponse>;
                                                                                                                              (
                                                                                                                              destination: Table,
                                                                                                                              metadata: CopyTableMetadata,
                                                                                                                              callback: JobCallback
                                                                                                                              ): void;
                                                                                                                              (destination: Table, callback: JobCallback): void;
                                                                                                                              };
                                                                                                                              • Copy data from one table to another, optionally creating that table.

                                                                                                                                See Jobs: insert API Documentation

                                                                                                                                Parameter destination

                                                                                                                                The destination table.

                                                                                                                                Parameter metadata

                                                                                                                                Metadata to set with the copy operation. The metadata object should be in the format of a `JobConfigurationTableCopy` object.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobId] Custom job id.

                                                                                                                                Parameter

                                                                                                                                {string} [metadata.jobPrefix] Prefix to apply to the job id.

                                                                                                                                Parameter callback

                                                                                                                                The callback function.

                                                                                                                                Parameter

                                                                                                                                {?error} callback.err An error returned while making this request

                                                                                                                                Parameter

                                                                                                                                {Job} callback.job The job used to copy your table.

                                                                                                                                Parameter

                                                                                                                                {object} callback.apiResponse The full API response.

                                                                                                                                Returns

                                                                                                                                {Promise}

                                                                                                                                Throws

                                                                                                                                {Error} If a destination other than a Table object is provided.

                                                                                                                                Example 1

                                                                                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                const bigquery = new BigQuery();
                                                                                                                                const dataset = bigquery.dataset('my-dataset');
                                                                                                                                const table = dataset.table('my-table');
                                                                                                                                const yourTable = dataset.table('your-table');
                                                                                                                                table.createCopyJob(yourTable, (err, job, apiResponse) => {
                                                                                                                                // `job` is a Job object that can be used to check the status of the
                                                                                                                                // request.
                                                                                                                                });
                                                                                                                                //-
                                                                                                                                // See https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy
                                                                                                                                // for all available options.
                                                                                                                                //-
                                                                                                                                const metadata = {
                                                                                                                                createDisposition: 'CREATE_NEVER',
                                                                                                                                writeDisposition: 'WRITE_TRUNCATE'
                                                                                                                                };
                                                                                                                                table.createCopyJob(yourTable, metadata, (err, job, apiResponse) => {});
                                                                                                                                //-
                                                                                                                                // If the callback is omitted, we'll return a Promise.
                                                                                                                                //-
                                                                                                                                table.createCopyJob(yourTable, metadata).then((data) => {
                                                                                                                                const job = data[0];
                                                                                                                                const apiResponse = data[1];
                                                                                                                                });

                                                                                                                              method createExtractJob

                                                                                                                              createExtractJob: {
                                                                                                                              (destination: File, options?: CreateExtractJobOptions): Promise<JobResponse>;
                                                                                                                              (
                                                                                                                              destination: File,
                                                                                                                              options: CreateExtractJobOptions,
                                                                                                                              callback: JobCallback
                                                                                                                              ): void;
                                                                                                                              (destination: File, callback: JobCallback): void;
                                                                                                                              };
                                                                                                                              • Export table to Cloud Storage.

                                                                                                                                See Jobs: insert API Documentation

                                                                                                                                Parameter destination

                                                                                                                                Where the file should be exported to. A string or a object.

                                                                                                                                Parameter options

                                                                                                                                The configuration object.

                                                                                                                                Parameter

                                                                                                                                {string} options.format - The format to export the data in. Allowed options are "CSV", "JSON", "AVRO", or "PARQUET". Default: "CSV".

                                                                                                                                Parameter

                                                                                                                                {boolean} options.gzip - Specify if you would like the file compressed with GZIP. Default: false.

                                                                                                                                Parameter

                                                                                                                                {string} [options.jobId] Custom job id.

                                                                                                                                Parameter

                                                                                                                                {string} [options.jobPrefix] Prefix to apply to the job id.

                                                                                                                                Parameter callback

                                                                                                                                The callback function.

                                                                                                                                Parameter

                                                                                                                                {?error} callback.err - An error returned while making this request

                                                                                                                                Parameter

                                                                                                                                {Job} callback.job - The job used to export the table.

                                                                                                                                Parameter

                                                                                                                                {object} callback.apiResponse - The full API response.

                                                                                                                                Returns

                                                                                                                                {Promise}

                                                                                                                                Throws

                                                                                                                                {Error} If destination isn't a File object.

                                                                                                                                Throws

                                                                                                                                {Error} If destination format isn't recongized.

                                                                                                                                Example 1

                                                                                                                                const {Storage} = require('@google-cloud/storage');
                                                                                                                                const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                const bigquery = new BigQuery();
                                                                                                                                const dataset = bigquery.dataset('my-dataset');
                                                                                                                                const table = dataset.table('my-table');
                                                                                                                                const storage = new Storage({
                                                                                                                                projectId: 'grape-spaceship-123'
                                                                                                                                });
                                                                                                                                const extractedFile = storage.bucket('institutions').file('2014.csv');
                                                                                                                                function callback(err, job, apiResponse) {
                                                                                                                                // `job` is a Job object that can be used to check the status of the
                                                                                                                                // request.
                                                                                                                                }
                                                                                                                                //-
                                                                                                                                // To use the default options, just pass a {@link
                                                                                                                                https://googleapis.dev/nodejs/storage/latest/File.html File}
                                                                                                                                object.
                                                                                                                                //
                                                                                                                                // Note: The exported format type will be inferred by the file's extension.
                                                                                                                                // If you wish to override this, or provide an array of destination files,
                                                                                                                                // you must provide an `options` object.
                                                                                                                                //-
                                                                                                                                table.createExtractJob(extractedFile, callback);
                                                                                                                                //-
                                                                                                                                // If you need more customization, pass an `options` object.
                                                                                                                                //-
                                                                                                                                const options = {
                                                                                                                                format: 'json',
                                                                                                                                gzip: true
                                                                                                                                };
                                                                                                                                table.createExtractJob(extractedFile, options, callback);
                                                                                                                                //-
                                                                                                                                // You can also specify multiple destination files.
                                                                                                                                //-
                                                                                                                                table.createExtractJob([
                                                                                                                                storage.bucket('institutions').file('2014.json'),
                                                                                                                                storage.bucket('institutions-copy').file('2014.json')
                                                                                                                                ], options, callback);
                                                                                                                                //-
                                                                                                                                // If the callback is omitted, we'll return a Promise.
                                                                                                                                //-
                                                                                                                                table.createExtractJob(extractedFile, options).then((data) => {
                                                                                                                                const job = data[0];
                                                                                                                                const apiResponse = data[1];
                                                                                                                                });

                                                                                                                              method createInsertStream

                                                                                                                              createInsertStream: (options?: InsertStreamOptions) => Writable;

                                                                                                                                method createLoadJob

                                                                                                                                createLoadJob: {
                                                                                                                                (
                                                                                                                                source: string | File | File[],
                                                                                                                                metadata?: JobLoadMetadata
                                                                                                                                ): Promise<JobResponse>;
                                                                                                                                (
                                                                                                                                source: string | File | File[],
                                                                                                                                metadata: JobLoadMetadata,
                                                                                                                                callback: JobCallback
                                                                                                                                ): void;
                                                                                                                                (source: string | File | File[], callback: JobCallback): void;
                                                                                                                                };
                                                                                                                                • Load data from a local file or Storage .

                                                                                                                                  By loading data this way, you create a load job that will run your data load asynchronously. If you would like instantaneous access to your data, insert it using .

                                                                                                                                  Note: The file type will be inferred by the given file's extension. If you wish to override this, you must provide metadata.format.

                                                                                                                                  See Jobs: insert API Documentation

                                                                                                                                  Parameter source

                                                                                                                                  The source file to load. A string (path) to a local file, or one or more objects.

                                                                                                                                  Parameter metadata

                                                                                                                                  Metadata to set with the load operation. The metadata object should be in the format of the `configuration.load` property of a Jobs resource.

                                                                                                                                  Parameter

                                                                                                                                  {string} [metadata.format] The format the data being loaded is in. Allowed options are "AVRO", "CSV", "JSON", "ORC", or "PARQUET".

                                                                                                                                  Parameter

                                                                                                                                  {string} [metadata.jobId] Custom job id.

                                                                                                                                  Parameter

                                                                                                                                  {string} [metadata.jobPrefix] Prefix to apply to the job id.

                                                                                                                                  Parameter callback

                                                                                                                                  The callback function.

                                                                                                                                  Parameter

                                                                                                                                  {?error} callback.err An error returned while making this request

                                                                                                                                  Parameter

                                                                                                                                  {Job} callback.job The job used to load your data.

                                                                                                                                  Parameter

                                                                                                                                  {object} callback.apiResponse The full API response.

                                                                                                                                  Returns

                                                                                                                                  {Promise}

                                                                                                                                  Throws

                                                                                                                                  {Error} If the source isn't a string file name or a File instance.

                                                                                                                                  Example 1

                                                                                                                                  const {Storage} = require('@google-cloud/storage');
                                                                                                                                  const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                  const bigquery = new BigQuery();
                                                                                                                                  const dataset = bigquery.dataset('my-dataset');
                                                                                                                                  const table = dataset.table('my-table');
                                                                                                                                  //-
                                                                                                                                  // Load data from a local file.
                                                                                                                                  //-
                                                                                                                                  const callback = (err, job, apiResponse) => {
                                                                                                                                  // `job` is a Job object that can be used to check the status of the
                                                                                                                                  // request.
                                                                                                                                  };
                                                                                                                                  table.createLoadJob('./institutions.csv', callback);
                                                                                                                                  //-
                                                                                                                                  // You may also pass in metadata in the format of a Jobs resource. See
                                                                                                                                  // (https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad)
                                                                                                                                  // for a full list of supported values.
                                                                                                                                  //-
                                                                                                                                  const metadata = {
                                                                                                                                  encoding: 'ISO-8859-1',
                                                                                                                                  sourceFormat: 'NEWLINE_DELIMITED_JSON'
                                                                                                                                  };
                                                                                                                                  table.createLoadJob('./my-data.csv', metadata, callback);
                                                                                                                                  //-
                                                                                                                                  // Load data from a file in your Cloud Storage bucket.
                                                                                                                                  //-
                                                                                                                                  const storage = new Storage({
                                                                                                                                  projectId: 'grape-spaceship-123'
                                                                                                                                  });
                                                                                                                                  const data = storage.bucket('institutions').file('data.csv');
                                                                                                                                  table.createLoadJob(data, callback);
                                                                                                                                  //-
                                                                                                                                  // Load data from multiple files in your Cloud Storage bucket(s).
                                                                                                                                  //-
                                                                                                                                  table.createLoadJob([
                                                                                                                                  storage.bucket('institutions').file('2011.csv'),
                                                                                                                                  storage.bucket('institutions').file('2012.csv')
                                                                                                                                  ], callback);
                                                                                                                                  //-
                                                                                                                                  // If the callback is omitted, we'll return a Promise.
                                                                                                                                  //-
                                                                                                                                  table.createLoadJob(data).then((data) => {
                                                                                                                                  const job = data[0];
                                                                                                                                  const apiResponse = data[1];
                                                                                                                                  });

                                                                                                                                method createQueryJob

                                                                                                                                createQueryJob: {
                                                                                                                                (options: Query): Promise<JobResponse>;
                                                                                                                                (options: Query, callback: JobCallback): void;
                                                                                                                                };
                                                                                                                                • Run a query as a job. No results are immediately returned. Instead, your callback will be executed with a Job object that you must ping for the results. See the Job documentation for explanations of how to check on the status of the job.

                                                                                                                                  See BigQuery#createQueryJob for full documentation of this method.

                                                                                                                                method createQueryStream

                                                                                                                                createQueryStream: (query: Query) => Duplex;

                                                                                                                                method createReadStream

                                                                                                                                createReadStream: (options?: GetRowsOptions) => ResourceStream<any>;

                                                                                                                                  method createSchemaFromString_

                                                                                                                                  static createSchemaFromString_: (str: string) => TableSchema;
                                                                                                                                  • Convert a comma-separated name:type string to a table schema object.

                                                                                                                                    Parameter str

                                                                                                                                    Comma-separated schema string.

                                                                                                                                    Returns

                                                                                                                                    {object} Table schema in the format the API expects.

                                                                                                                                  method createWriteStream

                                                                                                                                  createWriteStream: (metadata: JobLoadMetadata | string) => Writable;
                                                                                                                                  • Load data into your table from a readable stream of AVRO, CSV, JSON, ORC, or PARQUET data.

                                                                                                                                    See Jobs: insert API Documentation

                                                                                                                                    Parameter metadata

                                                                                                                                    Metadata to set with the load operation. The metadata object should be in the format of the `configuration.load` property of a Jobs resource. If a string is given, it will be used as the filetype.

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.jobId] Custom job id.

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.jobPrefix] Prefix to apply to the job id.

                                                                                                                                    Returns

                                                                                                                                    {WritableStream}

                                                                                                                                    Throws

                                                                                                                                    {Error} If source format isn't recognized.

                                                                                                                                    Example 1

                                                                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                    const bigquery = new BigQuery();
                                                                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                                                                    const table = dataset.table('my-table');
                                                                                                                                    //-
                                                                                                                                    // Load data from a CSV file.
                                                                                                                                    //-
                                                                                                                                    const request = require('request');
                                                                                                                                    const csvUrl = 'http://goo.gl/kSE7z6';
                                                                                                                                    const metadata = {
                                                                                                                                    allowJaggedRows: true,
                                                                                                                                    skipLeadingRows: 1
                                                                                                                                    };
                                                                                                                                    request.get(csvUrl)
                                                                                                                                    .pipe(table.createWriteStream(metadata))
                                                                                                                                    .on('job', (job) => {
                                                                                                                                    // `job` is a Job object that can be used to check the status of the
                                                                                                                                    // request.
                                                                                                                                    })
                                                                                                                                    .on('complete', (job) => {
                                                                                                                                    // The job has completed successfully.
                                                                                                                                    });
                                                                                                                                    //-
                                                                                                                                    // Load data from a JSON file.
                                                                                                                                    //-
                                                                                                                                    const fs = require('fs');
                                                                                                                                    fs.createReadStream('./test/testdata/testfile.json')
                                                                                                                                    .pipe(table.createWriteStream('json'))
                                                                                                                                    .on('job', (job) => {
                                                                                                                                    // `job` is a Job object that can be used to check the status of the
                                                                                                                                    // request.
                                                                                                                                    })
                                                                                                                                    .on('complete', (job) => {
                                                                                                                                    // The job has completed successfully.
                                                                                                                                    });

                                                                                                                                  method createWriteStream_

                                                                                                                                  createWriteStream_: (metadata: JobLoadMetadata | string) => Writable;
                                                                                                                                  • Creates a write stream. Unlike the public version, this will not automatically poll the underlying job.

                                                                                                                                    Parameter metadata

                                                                                                                                    Metadata to set with the load operation. The metadata object should be in the format of the `configuration.load` property of a Jobs resource. If a string is given, it will be used as the filetype.

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.jobId] Custom job id.

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.jobPrefix] Prefix to apply to the job id.

                                                                                                                                    Returns

                                                                                                                                    {WritableStream}

                                                                                                                                  method encodeValue_

                                                                                                                                  static encodeValue_: (value?: {} | null) => {} | null;
                                                                                                                                  • Convert a row entry from native types to their encoded types that the API expects.

                                                                                                                                    Parameter value

                                                                                                                                    The value to be converted.

                                                                                                                                    Returns

                                                                                                                                    {*} The converted value.

                                                                                                                                  method extract

                                                                                                                                  extract: {
                                                                                                                                  (
                                                                                                                                  destination: File,
                                                                                                                                  options?: CreateExtractJobOptions
                                                                                                                                  ): Promise<JobMetadataResponse>;
                                                                                                                                  (
                                                                                                                                  destination: File,
                                                                                                                                  options: CreateExtractJobOptions,
                                                                                                                                  callback?: JobMetadataCallback
                                                                                                                                  ): void;
                                                                                                                                  (destination: File, callback?: JobMetadataCallback): void;
                                                                                                                                  };
                                                                                                                                  • Export table to Cloud Storage.

                                                                                                                                    Parameter destination

                                                                                                                                    Where the file should be exported to. A string or a .

                                                                                                                                    Parameter options

                                                                                                                                    The configuration object.

                                                                                                                                    Parameter

                                                                                                                                    {string} [options.format="CSV"] The format to export the data in. Allowed options are "AVRO", "CSV", "JSON", "ORC" or "PARQUET".

                                                                                                                                    Parameter

                                                                                                                                    {boolean} [options.gzip] Specify if you would like the file compressed with GZIP. Default: false.

                                                                                                                                    Parameter

                                                                                                                                    {string} [options.jobId] Custom id for the underlying job.

                                                                                                                                    Parameter

                                                                                                                                    {string} [options.jobPrefix] Prefix to apply to the underlying job id.

                                                                                                                                    Parameter callback

                                                                                                                                    The callback function.

                                                                                                                                    Parameter

                                                                                                                                    {?error} callback.err An error returned while making this request

                                                                                                                                    Parameter

                                                                                                                                    {object} callback.apiResponse The full API response.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                    Throws

                                                                                                                                    {Error} If destination isn't a File object.

                                                                                                                                    Throws

                                                                                                                                    {Error} If destination format isn't recongized.

                                                                                                                                    Example 1

                                                                                                                                    const Storage = require('@google-cloud/storage');
                                                                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                    const bigquery = new BigQuery();
                                                                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                                                                    const table = dataset.table('my-table');
                                                                                                                                    const storage = new Storage({
                                                                                                                                    projectId: 'grape-spaceship-123'
                                                                                                                                    });
                                                                                                                                    const extractedFile = storage.bucket('institutions').file('2014.csv');
                                                                                                                                    //-
                                                                                                                                    // To use the default options, just pass a {@link
                                                                                                                                    https://googleapis.dev/nodejs/storage/latest/File.html File}
                                                                                                                                    object.
                                                                                                                                    //
                                                                                                                                    // Note: The exported format type will be inferred by the file's extension.
                                                                                                                                    // If you wish to override this, or provide an array of destination files,
                                                                                                                                    // you must provide an `options` object.
                                                                                                                                    //-
                                                                                                                                    table.extract(extractedFile, (err, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // If you need more customization, pass an `options` object.
                                                                                                                                    //-
                                                                                                                                    const options = {
                                                                                                                                    format: 'json',
                                                                                                                                    gzip: true
                                                                                                                                    };
                                                                                                                                    table.extract(extractedFile, options, (err, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // You can also specify multiple destination files.
                                                                                                                                    //-
                                                                                                                                    table.extract([
                                                                                                                                    storage.bucket('institutions').file('2014.json'),
                                                                                                                                    storage.bucket('institutions-copy').file('2014.json')
                                                                                                                                    ], options, (err, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // If the callback is omitted, we'll return a Promise.
                                                                                                                                    //-
                                                                                                                                    table.extract(extractedFile, options).then((data) => {
                                                                                                                                    const apiResponse = data[0];
                                                                                                                                    });

                                                                                                                                  method formatMetadata_

                                                                                                                                  static formatMetadata_: (options: TableMetadata) => FormattedMetadata;

                                                                                                                                  method getIamPolicy

                                                                                                                                  getIamPolicy: {
                                                                                                                                  (
                                                                                                                                  optionsOrCallback?: GetPolicyOptions | PolicyCallback
                                                                                                                                  ): Promise<PolicyResponse>;
                                                                                                                                  (options: bigquery.IGetPolicyOptions, callback: PolicyCallback): void;
                                                                                                                                  };
                                                                                                                                  • Run a query scoped to your dataset.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                  method getRows

                                                                                                                                  getRows: {
                                                                                                                                  (options?: GetRowsOptions): Promise<RowsResponse>;
                                                                                                                                  (options: GetRowsOptions, callback: RowsCallback): void;
                                                                                                                                  (callback: RowsCallback): void;
                                                                                                                                  };
                                                                                                                                  • {array} RowsResponse {array} 0 The rows.

                                                                                                                                  method insert

                                                                                                                                  insert: {
                                                                                                                                  (
                                                                                                                                  rows: RowMetadata | RowMetadata[],
                                                                                                                                  options?: InsertRowsOptions
                                                                                                                                  ): Promise<InsertRowsResponse>;
                                                                                                                                  (rows: any, options: InsertRowsOptions, callback: InsertRowsCallback): void;
                                                                                                                                  (rows: any, callback: InsertRowsCallback): void;
                                                                                                                                  };
                                                                                                                                  • Stream data into BigQuery one record at a time without running a load job.

                                                                                                                                    If you need to create an entire table from a file, consider using Table#load instead.

                                                                                                                                    Note, if a table was recently created, inserts may fail until the table is consistent within BigQuery. If a schema is supplied, this method will automatically retry those failed inserts, and it will even create the table with the provided schema if it does not exist.

                                                                                                                                    See Tabledata: insertAll API Documentation See Streaming Insert Limits See Troubleshooting Errors

                                                                                                                                    Parameter rows

                                                                                                                                    The rows to insert into the table.

                                                                                                                                    Parameter options

                                                                                                                                    Configuration object.

                                                                                                                                    Parameter

                                                                                                                                    {boolean} [options.createInsertId=true] Automatically insert a default row id when one is not provided.

                                                                                                                                    Parameter

                                                                                                                                    {boolean} [options.ignoreUnknownValues=false] Accept rows that contain values that do not match the schema. The unknown values are ignored.

                                                                                                                                    Parameter

                                                                                                                                    {number} [options.partialRetries=3] Number of times to retry inserting rows for cases of partial failures.

                                                                                                                                    Parameter

                                                                                                                                    {boolean} [options.raw] If true, the rows argument is expected to be formatted as according to the specification.

                                                                                                                                    Parameter

                                                                                                                                    {string|object} [options.schema] If provided will automatically create a table if it doesn't already exist. Note that this can take longer than 2 minutes to complete. A comma-separated list of name:type pairs. Valid types are "string", "integer", "float", "boolean", and "timestamp". If the type is omitted, it is assumed to be "string". Example: "name:string, age:integer". Schemas can also be specified as a JSON array of fields, which allows for nested and repeated fields. See a Table resource for more detailed information.

                                                                                                                                    Parameter

                                                                                                                                    {boolean} [options.skipInvalidRows=false] Insert all valid rows of a request, even if invalid rows exist.

                                                                                                                                    Parameter

                                                                                                                                    {string} [options.templateSuffix] Treat the destination table as a base template, and insert the rows into an instance table named "{destination}{templateSuffix}". BigQuery will manage creation of the instance table, using the schema of the base template table. See Automatic table creation using template tables for considerations when working with templates tables.

                                                                                                                                    Parameter callback

                                                                                                                                    The callback function.

                                                                                                                                    Parameter

                                                                                                                                    {?error} callback.err An error returned while making this request.

                                                                                                                                    Parameter

                                                                                                                                    {object[]} callback.err.errors If present, these represent partial failures. It's possible for part of your request to be completed successfully, while the other part was not.

                                                                                                                                    Parameter

                                                                                                                                    {object} callback.apiResponse The full API response.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                    Example 1

                                                                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                    const bigquery = new BigQuery();
                                                                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                                                                    const table = dataset.table('my-table');
                                                                                                                                    //-
                                                                                                                                    // Insert a single row.
                                                                                                                                    //-
                                                                                                                                    table.insert({
                                                                                                                                    INSTNM: 'Motion Picture Institute of Michigan',
                                                                                                                                    CITY: 'Troy',
                                                                                                                                    STABBR: 'MI'
                                                                                                                                    }, insertHandler);
                                                                                                                                    //-
                                                                                                                                    // Insert multiple rows at a time.
                                                                                                                                    //-
                                                                                                                                    const rows = [
                                                                                                                                    {
                                                                                                                                    INSTNM: 'Motion Picture Institute of Michigan',
                                                                                                                                    CITY: 'Troy',
                                                                                                                                    STABBR: 'MI'
                                                                                                                                    },
                                                                                                                                    // ...
                                                                                                                                    ];
                                                                                                                                    table.insert(rows, insertHandler);
                                                                                                                                    //-
                                                                                                                                    // Insert a row as according to the <a href="https://cloud.google.com/bigquery/docs/reference/v2/tabledata/insertAll">specification</a>.
                                                                                                                                    //-
                                                                                                                                    const row = {
                                                                                                                                    insertId: '1',
                                                                                                                                    json: {
                                                                                                                                    INSTNM: 'Motion Picture Institute of Michigan',
                                                                                                                                    CITY: 'Troy',
                                                                                                                                    STABBR: 'MI'
                                                                                                                                    }
                                                                                                                                    };
                                                                                                                                    const options = {
                                                                                                                                    raw: true
                                                                                                                                    };
                                                                                                                                    table.insert(row, options, insertHandler);
                                                                                                                                    //-
                                                                                                                                    // Handling the response. See <a href="https://developers.google.com/bigquery/troubleshooting-errors">Troubleshooting Errors</a> for best practices on how to handle errors.
                                                                                                                                    //-
                                                                                                                                    function insertHandler(err, apiResponse) {
                                                                                                                                    if (err) {
                                                                                                                                    // An API error or partial failure occurred.
                                                                                                                                    if (err.name === 'PartialFailureError') {
                                                                                                                                    // Some rows failed to insert, while others may have succeeded.
                                                                                                                                    // err.errors (object[]):
                                                                                                                                    // err.errors[].row (original row object passed to `insert`)
                                                                                                                                    // err.errors[].errors[].reason
                                                                                                                                    // err.errors[].errors[].message
                                                                                                                                    }
                                                                                                                                    }
                                                                                                                                    }
                                                                                                                                    //-
                                                                                                                                    // If the callback is omitted, we'll return a Promise.
                                                                                                                                    //-
                                                                                                                                    table.insert(rows)
                                                                                                                                    .then((data) => {
                                                                                                                                    const apiResponse = data[0];
                                                                                                                                    })
                                                                                                                                    .catch((err) => {
                                                                                                                                    // An API error or partial failure occurred.
                                                                                                                                    if (err.name === 'PartialFailureError') {
                                                                                                                                    // Some rows failed to insert, while others may have succeeded.
                                                                                                                                    // err.errors (object[]):
                                                                                                                                    // err.errors[].row (original row object passed to `insert`)
                                                                                                                                    // err.errors[].errors[].reason
                                                                                                                                    // err.errors[].errors[].message
                                                                                                                                    }
                                                                                                                                    });

                                                                                                                                  method load

                                                                                                                                  load: {
                                                                                                                                  (
                                                                                                                                  source: string | File | File[],
                                                                                                                                  metadata?: JobLoadMetadata
                                                                                                                                  ): Promise<JobMetadataResponse>;
                                                                                                                                  (
                                                                                                                                  source: string | File | File[],
                                                                                                                                  metadata: JobLoadMetadata,
                                                                                                                                  callback: JobMetadataCallback
                                                                                                                                  ): void;
                                                                                                                                  (source: string | File | File[], callback: JobMetadataCallback): void;
                                                                                                                                  (
                                                                                                                                  source: string | File | File[],
                                                                                                                                  metadata?: JobLoadMetadata
                                                                                                                                  ): Promise<JobMetadataResponse>;
                                                                                                                                  (
                                                                                                                                  source: string | File | File[],
                                                                                                                                  metadata: JobLoadMetadata,
                                                                                                                                  callback: JobMetadataCallback
                                                                                                                                  ): void;
                                                                                                                                  (source: string | File | File[], callback: JobMetadataCallback): void;
                                                                                                                                  };
                                                                                                                                  • Load data from a local file or Storage .

                                                                                                                                    By loading data this way, you create a load job that will run your data load asynchronously. If you would like instantaneous access to your data, insert it using Table#insert.

                                                                                                                                    Note: The file type will be inferred by the given file's extension. If you wish to override this, you must provide metadata.format.

                                                                                                                                    Parameter source

                                                                                                                                    The source file to load. A filepath as a string or a object.

                                                                                                                                    Parameter metadata

                                                                                                                                    Metadata to set with the load operation. The metadata object should be in the format of the `configuration.load` property of a Jobs resource.

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.format] The format the data being loaded is in. Allowed options are "AVRO", "CSV", "JSON", "ORC", or "PARQUET".

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.jobId] Custom id for the underlying job.

                                                                                                                                    Parameter

                                                                                                                                    {string} [metadata.jobPrefix] Prefix to apply to the underlying job id.

                                                                                                                                    Parameter callback

                                                                                                                                    The callback function.

                                                                                                                                    Parameter

                                                                                                                                    {?error} callback.err An error returned while making this request

                                                                                                                                    Parameter

                                                                                                                                    {object} callback.apiResponse The full API response.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                    Throws

                                                                                                                                    {Error} If the source isn't a string file name or a File instance.

                                                                                                                                    Example 1

                                                                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                    const bigquery = new BigQuery();
                                                                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                                                                    const table = dataset.table('my-table');
                                                                                                                                    //-
                                                                                                                                    // Load data from a local file.
                                                                                                                                    //-
                                                                                                                                    table.load('./institutions.csv', (err, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // You may also pass in metadata in the format of a Jobs resource. See
                                                                                                                                    // (https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad)
                                                                                                                                    // for a full list of supported values.
                                                                                                                                    //-
                                                                                                                                    const metadata = {
                                                                                                                                    encoding: 'ISO-8859-1',
                                                                                                                                    sourceFormat: 'NEWLINE_DELIMITED_JSON'
                                                                                                                                    };
                                                                                                                                    table.load('./my-data.csv', metadata, (err, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // Load data from a file in your Cloud Storage bucket.
                                                                                                                                    //-
                                                                                                                                    const gcs = require('@google-cloud/storage')({
                                                                                                                                    projectId: 'grape-spaceship-123'
                                                                                                                                    });
                                                                                                                                    const data = gcs.bucket('institutions').file('data.csv');
                                                                                                                                    table.load(data, (err, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // Load data from multiple files in your Cloud Storage bucket(s).
                                                                                                                                    //-
                                                                                                                                    table.load([
                                                                                                                                    gcs.bucket('institutions').file('2011.csv'),
                                                                                                                                    gcs.bucket('institutions').file('2012.csv')
                                                                                                                                    ], function(err, apiResponse) {});
                                                                                                                                    //-
                                                                                                                                    // If the callback is omitted, we'll return a Promise.
                                                                                                                                    //-
                                                                                                                                    table.load(data).then(function(data) {
                                                                                                                                    const apiResponse = data[0];
                                                                                                                                    });

                                                                                                                                  method query

                                                                                                                                  query: {
                                                                                                                                  (query: Query): Promise<SimpleQueryRowsResponse>;
                                                                                                                                  (query: string): Promise<SimpleQueryRowsResponse>;
                                                                                                                                  (query: Query, callback: SimpleQueryRowsCallback): void;
                                                                                                                                  };
                                                                                                                                  • Run a query scoped to your dataset.

                                                                                                                                    See BigQuery#query for full documentation of this method.

                                                                                                                                    Parameter query

                                                                                                                                    See BigQuery#query for full documentation of this method.

                                                                                                                                    Parameter callback

                                                                                                                                    See BigQuery#query for full documentation of this method.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                  method setIamPolicy

                                                                                                                                  setIamPolicy: {
                                                                                                                                  (policy: Policy, options?: SetPolicyOptions): Promise<PolicyResponse>;
                                                                                                                                  (
                                                                                                                                  policy: bigquery.IPolicy,
                                                                                                                                  options: SetPolicyOptions,
                                                                                                                                  callback: PolicyCallback
                                                                                                                                  ): void;
                                                                                                                                  (policy: bigquery.IPolicy, callback: PolicyCallback): void;
                                                                                                                                  };
                                                                                                                                  • Run a query scoped to your dataset.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                  method setMetadata

                                                                                                                                  setMetadata: {
                                                                                                                                  (metadata: SetTableMetadataOptions): Promise<SetMetadataResponse>;
                                                                                                                                  (metadata: TableMetadata, callback: ResponseCallback): void;
                                                                                                                                  };
                                                                                                                                  • Set the metadata on the table.

                                                                                                                                    See Tables: patch API Documentation

                                                                                                                                    Parameter metadata

                                                                                                                                    The metadata key/value object to set.

                                                                                                                                    Parameter

                                                                                                                                    {string} metadata.description A user-friendly description of the table.

                                                                                                                                    Parameter

                                                                                                                                    {string} metadata.name A descriptive name for the table.

                                                                                                                                    Parameter

                                                                                                                                    {string|object} metadata.schema A comma-separated list of name:type pairs. Valid types are "string", "integer", "float", "boolean", "bytes", "record", and "timestamp". If the type is omitted, it is assumed to be "string". Example: "name:string, age:integer". Schemas can also be specified as a JSON array of fields, which allows for nested and repeated fields. See a Table resource for more detailed information.

                                                                                                                                    Parameter callback

                                                                                                                                    The callback function.

                                                                                                                                    Parameter

                                                                                                                                    {?error} callback.err An error returned while making this request.

                                                                                                                                    Parameter

                                                                                                                                    {object} callback.apiResponse The full API response.

                                                                                                                                    Returns

                                                                                                                                    {Promise<common.SetMetadataResponse>}

                                                                                                                                    Example 1

                                                                                                                                    const {BigQuery} = require('@google-cloud/bigquery');
                                                                                                                                    const bigquery = new BigQuery();
                                                                                                                                    const dataset = bigquery.dataset('my-dataset');
                                                                                                                                    const table = dataset.table('my-table');
                                                                                                                                    const metadata = {
                                                                                                                                    name: 'My recipes',
                                                                                                                                    description: 'A table for storing my recipes.',
                                                                                                                                    schema: 'name:string, servings:integer, cookingTime:float, quick:boolean'
                                                                                                                                    };
                                                                                                                                    table.setMetadata(metadata, (err, metadata, apiResponse) => {});
                                                                                                                                    //-
                                                                                                                                    // If the callback is omitted, we'll return a Promise.
                                                                                                                                    //-
                                                                                                                                    table.setMetadata(metadata).then((data) => {
                                                                                                                                    const metadata = data[0];
                                                                                                                                    const apiResponse = data[1];
                                                                                                                                    });

                                                                                                                                  method testIamPermissions

                                                                                                                                  testIamPermissions: {
                                                                                                                                  (permissions: string | string[]): Promise<PermissionsResponse>;
                                                                                                                                  (permissions: string | string[], callback: PermissionsCallback): void;
                                                                                                                                  };
                                                                                                                                  • Run a query scoped to your dataset.

                                                                                                                                    Returns

                                                                                                                                    {Promise}

                                                                                                                                  Interfaces

                                                                                                                                  interface BigQueryDateOptions

                                                                                                                                  interface BigQueryDateOptions {}

                                                                                                                                    property day

                                                                                                                                    day?: number | string;

                                                                                                                                      property month

                                                                                                                                      month?: number | string;

                                                                                                                                        property year

                                                                                                                                        year?: number | string;

                                                                                                                                          interface BigQueryDatetimeOptions

                                                                                                                                          interface BigQueryDatetimeOptions {}

                                                                                                                                            property day

                                                                                                                                            day?: string | number;

                                                                                                                                              property fractional

                                                                                                                                              fractional?: string | number;

                                                                                                                                                property hours

                                                                                                                                                hours?: string | number;

                                                                                                                                                  property minutes

                                                                                                                                                  minutes?: string | number;

                                                                                                                                                    property month

                                                                                                                                                    month?: string | number;

                                                                                                                                                      property seconds

                                                                                                                                                      seconds?: string | number;

                                                                                                                                                        property year

                                                                                                                                                        year?: string | number;

                                                                                                                                                          interface BigQueryOptions

                                                                                                                                                          interface BigQueryOptions extends GoogleAuthOptions {}

                                                                                                                                                            property apiEndpoint

                                                                                                                                                            apiEndpoint?: string;
                                                                                                                                                            • The API endpoint of the service used to make requests. Defaults to bigquery.googleapis.com.

                                                                                                                                                            property autoRetry

                                                                                                                                                            autoRetry?: boolean;
                                                                                                                                                            • Automatically retry requests if the response is related to rate limits or certain intermittent server errors. We will exponentially backoff subsequent requests by default.

                                                                                                                                                              Defaults to true.

                                                                                                                                                            property location

                                                                                                                                                            location?: string;
                                                                                                                                                            • The geographic location of all datasets and jobs referenced and created through the client.

                                                                                                                                                            property maxRetries

                                                                                                                                                            maxRetries?: number;
                                                                                                                                                            • Maximum number of automatic retries attempted before returning the error.

                                                                                                                                                              Defaults to 3.

                                                                                                                                                            property universeDomain

                                                                                                                                                            universeDomain?: string;
                                                                                                                                                            • The Trusted Cloud Domain (TPC) DNS of the service used to make requests. Defaults to googleapis.com.

                                                                                                                                                            property userAgent

                                                                                                                                                            userAgent?: string;
                                                                                                                                                            • The value to be prepended to the User-Agent header in API requests.

                                                                                                                                                            interface BigQueryTimeOptions

                                                                                                                                                            interface BigQueryTimeOptions {}

                                                                                                                                                              property fractional

                                                                                                                                                              fractional?: number | string;

                                                                                                                                                                property hours

                                                                                                                                                                hours?: number | string;

                                                                                                                                                                  property minutes

                                                                                                                                                                  minutes?: number | string;

                                                                                                                                                                    property seconds

                                                                                                                                                                    seconds?: number | string;

                                                                                                                                                                      interface DatasetDeleteOptions

                                                                                                                                                                      interface DatasetDeleteOptions {}

                                                                                                                                                                        property force

                                                                                                                                                                        force?: boolean;

                                                                                                                                                                          interface DatasetOptions

                                                                                                                                                                          interface DatasetOptions {}

                                                                                                                                                                            property location

                                                                                                                                                                            location?: string;

                                                                                                                                                                              property projectId

                                                                                                                                                                              projectId?: string;

                                                                                                                                                                                interface File

                                                                                                                                                                                interface File {}

                                                                                                                                                                                  property bucket

                                                                                                                                                                                  bucket: any;

                                                                                                                                                                                    property generation

                                                                                                                                                                                    generation?: number;

                                                                                                                                                                                      property kmsKeyName

                                                                                                                                                                                      kmsKeyName?: string;

                                                                                                                                                                                        property name

                                                                                                                                                                                        name: string;

                                                                                                                                                                                          property userProject

                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                            interface InsertRow

                                                                                                                                                                                            interface InsertRow {}

                                                                                                                                                                                              property insertId

                                                                                                                                                                                              insertId?: string;

                                                                                                                                                                                                property json

                                                                                                                                                                                                json?: bigquery.IJsonObject;

                                                                                                                                                                                                  interface InsertStreamOptions

                                                                                                                                                                                                  interface InsertStreamOptions {}

                                                                                                                                                                                                    property batchOptions

                                                                                                                                                                                                    batchOptions?: RowBatchOptions;

                                                                                                                                                                                                      property insertRowsOptions

                                                                                                                                                                                                      insertRowsOptions?: InsertRowsOptions;

                                                                                                                                                                                                        interface IntegerTypeCastOptions

                                                                                                                                                                                                        interface IntegerTypeCastOptions {}

                                                                                                                                                                                                          property fields

                                                                                                                                                                                                          fields?: string | string[];

                                                                                                                                                                                                            property integerTypeCastFunction

                                                                                                                                                                                                            integerTypeCastFunction: Function;

                                                                                                                                                                                                              interface Json

                                                                                                                                                                                                              interface Json {}

                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                [field: string]: string;

                                                                                                                                                                                                                  interface PagedCallback

                                                                                                                                                                                                                  interface PagedCallback<T, Q, R> {}

                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                    (
                                                                                                                                                                                                                    err: Error | null,
                                                                                                                                                                                                                    resource?: T[] | null,
                                                                                                                                                                                                                    nextQuery?: Q | null,
                                                                                                                                                                                                                    response?: R | null
                                                                                                                                                                                                                    ): void;

                                                                                                                                                                                                                      interface PartialInsertFailure

                                                                                                                                                                                                                      interface PartialInsertFailure {}

                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                        message: string;

                                                                                                                                                                                                                          property reason

                                                                                                                                                                                                                          reason: string;

                                                                                                                                                                                                                            property row

                                                                                                                                                                                                                            row: RowMetadata;

                                                                                                                                                                                                                              interface ProvidedTypeStruct

                                                                                                                                                                                                                              interface ProvidedTypeStruct {}

                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                [key: string]: string | ProvidedTypeArray | ProvidedTypeStruct;

                                                                                                                                                                                                                                  interface RequestCallback

                                                                                                                                                                                                                                  interface RequestCallback<T> {}

                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                    (err: Error | null, response?: T | null): void;

                                                                                                                                                                                                                                      interface ResourceCallback

                                                                                                                                                                                                                                      interface ResourceCallback<T, R> {}

                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                        (err: Error | null, resource?: T | null, response?: R | null): void;

                                                                                                                                                                                                                                          interface TableOptions

                                                                                                                                                                                                                                          interface TableOptions {}

                                                                                                                                                                                                                                            property location

                                                                                                                                                                                                                                            location?: string;

                                                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                                                              type CancelCallback

                                                                                                                                                                                                                                              type CancelCallback = RequestCallback<bigquery.IJobCancelResponse>;

                                                                                                                                                                                                                                                type CancelResponse

                                                                                                                                                                                                                                                type CancelResponse = [bigquery.IJobCancelResponse];

                                                                                                                                                                                                                                                  type CopyTableMetadata

                                                                                                                                                                                                                                                  type CopyTableMetadata = JobRequest<bigquery.IJobConfigurationTableCopy>;

                                                                                                                                                                                                                                                    type CreateCopyJobMetadata

                                                                                                                                                                                                                                                    type CreateCopyJobMetadata = CopyTableMetadata;

                                                                                                                                                                                                                                                      type CreateDatasetOptions

                                                                                                                                                                                                                                                      type CreateDatasetOptions = bigquery.IDataset;

                                                                                                                                                                                                                                                        type CreateExtractJobOptions

                                                                                                                                                                                                                                                        type CreateExtractJobOptions = JobRequest<bigquery.IJobConfigurationExtract> & {
                                                                                                                                                                                                                                                        format?: 'ML_TF_SAVED_MODEL' | 'ML_XGBOOST_BOOSTER';
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          type DatasetCallback

                                                                                                                                                                                                                                                          type DatasetCallback = ResourceCallback<Dataset, bigquery.IDataset>;

                                                                                                                                                                                                                                                            type DatasetResource

                                                                                                                                                                                                                                                            type DatasetResource = bigquery.IDataset & {
                                                                                                                                                                                                                                                            projectId?: string;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              type DatasetResponse

                                                                                                                                                                                                                                                              type DatasetResponse = [Dataset, bigquery.IDataset];

                                                                                                                                                                                                                                                                type DatasetsCallback

                                                                                                                                                                                                                                                                type DatasetsCallback = PagedCallback<
                                                                                                                                                                                                                                                                Dataset,
                                                                                                                                                                                                                                                                GetDatasetsOptions,
                                                                                                                                                                                                                                                                bigquery.IDatasetList
                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                  type DatasetsResponse

                                                                                                                                                                                                                                                                  type DatasetsResponse = PagedResponse<
                                                                                                                                                                                                                                                                  Dataset,
                                                                                                                                                                                                                                                                  GetDatasetsOptions,
                                                                                                                                                                                                                                                                  bigquery.IDatasetList
                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                    type FormattedMetadata

                                                                                                                                                                                                                                                                    type FormattedMetadata = bigquery.ITable;

                                                                                                                                                                                                                                                                      type GetDatasetsOptions

                                                                                                                                                                                                                                                                      type GetDatasetsOptions = PagedRequest<bigquery.datasets.IListParams> & {
                                                                                                                                                                                                                                                                      projectId?: string;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        type GetJobsCallback

                                                                                                                                                                                                                                                                        type GetJobsCallback = PagedCallback<Job, GetJobsOptions, bigquery.IJobList>;

                                                                                                                                                                                                                                                                          type GetJobsOptions

                                                                                                                                                                                                                                                                          type GetJobsOptions = PagedRequest<bigquery.jobs.IListParams>;

                                                                                                                                                                                                                                                                            type GetJobsResponse

                                                                                                                                                                                                                                                                            type GetJobsResponse = PagedResponse<Job, GetJobsOptions, bigquery.IJobList>;

                                                                                                                                                                                                                                                                              type GetModelsCallback

                                                                                                                                                                                                                                                                              type GetModelsCallback = PagedCallback<
                                                                                                                                                                                                                                                                              Model,
                                                                                                                                                                                                                                                                              GetModelsOptions,
                                                                                                                                                                                                                                                                              bigquery.IListModelsResponse
                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                type GetModelsOptions

                                                                                                                                                                                                                                                                                type GetModelsOptions = PagedRequest<bigquery.models.IListParams>;

                                                                                                                                                                                                                                                                                  type GetModelsResponse

                                                                                                                                                                                                                                                                                  type GetModelsResponse = PagedResponse<
                                                                                                                                                                                                                                                                                  Model,
                                                                                                                                                                                                                                                                                  GetModelsOptions,
                                                                                                                                                                                                                                                                                  bigquery.IListModelsResponse
                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                    type GetPolicyOptions

                                                                                                                                                                                                                                                                                    type GetPolicyOptions = bigquery.IGetPolicyOptions;

                                                                                                                                                                                                                                                                                      type GetRoutinesCallback

                                                                                                                                                                                                                                                                                      type GetRoutinesCallback = PagedCallback<
                                                                                                                                                                                                                                                                                      Routine,
                                                                                                                                                                                                                                                                                      GetRoutinesOptions,
                                                                                                                                                                                                                                                                                      bigquery.IListRoutinesResponse
                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                        type GetRoutinesOptions

                                                                                                                                                                                                                                                                                        type GetRoutinesOptions = PagedRequest<bigquery.routines.IListParams>;

                                                                                                                                                                                                                                                                                          type GetRoutinesResponse

                                                                                                                                                                                                                                                                                          type GetRoutinesResponse = PagedResponse<
                                                                                                                                                                                                                                                                                          Routine,
                                                                                                                                                                                                                                                                                          GetRoutinesOptions,
                                                                                                                                                                                                                                                                                          bigquery.IListRoutinesResponse
                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                            type GetRowsOptions

                                                                                                                                                                                                                                                                                            type GetRowsOptions = PagedRequest<bigquery.tabledata.IListParams> & {
                                                                                                                                                                                                                                                                                            wrapIntegers?: boolean | IntegerTypeCastOptions;
                                                                                                                                                                                                                                                                                            parseJSON?: boolean;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              type GetTablesCallback

                                                                                                                                                                                                                                                                                              type GetTablesCallback = PagedCallback<Table, GetTablesOptions, bigquery.ITableList>;

                                                                                                                                                                                                                                                                                                type GetTablesOptions

                                                                                                                                                                                                                                                                                                type GetTablesOptions = PagedRequest<bigquery.tables.IListParams>;

                                                                                                                                                                                                                                                                                                  type GetTablesResponse

                                                                                                                                                                                                                                                                                                  type GetTablesResponse = PagedResponse<Table, GetTablesOptions, bigquery.ITableList>;

                                                                                                                                                                                                                                                                                                    type InsertRowsCallback

                                                                                                                                                                                                                                                                                                    type InsertRowsCallback = RequestCallback<
                                                                                                                                                                                                                                                                                                    bigquery.ITableDataInsertAllResponse | bigquery.ITable
                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                      type InsertRowsOptions

                                                                                                                                                                                                                                                                                                      type InsertRowsOptions = bigquery.ITableDataInsertAllRequest & {
                                                                                                                                                                                                                                                                                                      createInsertId?: boolean;
                                                                                                                                                                                                                                                                                                      partialRetries?: number;
                                                                                                                                                                                                                                                                                                      raw?: boolean;
                                                                                                                                                                                                                                                                                                      schema?: string | {};
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        type InsertRowsResponse

                                                                                                                                                                                                                                                                                                        type InsertRowsResponse = [bigquery.ITableDataInsertAllResponse | bigquery.ITable];

                                                                                                                                                                                                                                                                                                          type InsertRowsStreamResponse

                                                                                                                                                                                                                                                                                                          type InsertRowsStreamResponse = bigquery.ITableDataInsertAllResponse;

                                                                                                                                                                                                                                                                                                            type IntegerTypeCastValue

                                                                                                                                                                                                                                                                                                            type IntegerTypeCastValue = {
                                                                                                                                                                                                                                                                                                            integerValue: string | number;
                                                                                                                                                                                                                                                                                                            schemaFieldName?: string;
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              type JobCallback

                                                                                                                                                                                                                                                                                                              type JobCallback = ResourceCallback<Job, bigquery.IJob>;

                                                                                                                                                                                                                                                                                                                type JobLoadMetadata

                                                                                                                                                                                                                                                                                                                type JobLoadMetadata = JobRequest<bigquery.IJobConfigurationLoad> & {
                                                                                                                                                                                                                                                                                                                format?: string;
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  type JobMetadata

                                                                                                                                                                                                                                                                                                                  type JobMetadata = bigquery.IJob;

                                                                                                                                                                                                                                                                                                                    type JobMetadataCallback

                                                                                                                                                                                                                                                                                                                    type JobMetadataCallback = RequestCallback<JobMetadata>;

                                                                                                                                                                                                                                                                                                                      type JobMetadataResponse

                                                                                                                                                                                                                                                                                                                      type JobMetadataResponse = [JobMetadata];

                                                                                                                                                                                                                                                                                                                        type JobOptions

                                                                                                                                                                                                                                                                                                                        type JobOptions = JobRequest<JobMetadata>;

                                                                                                                                                                                                                                                                                                                          type JobRequest

                                                                                                                                                                                                                                                                                                                          type JobRequest<J> = J & {
                                                                                                                                                                                                                                                                                                                          jobId?: string;
                                                                                                                                                                                                                                                                                                                          jobPrefix?: string;
                                                                                                                                                                                                                                                                                                                          location?: string;
                                                                                                                                                                                                                                                                                                                          projectId?: string;
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            type JobResponse

                                                                                                                                                                                                                                                                                                                            type JobResponse = [Job, bigquery.IJob];

                                                                                                                                                                                                                                                                                                                              type PagedRequest

                                                                                                                                                                                                                                                                                                                              type PagedRequest<P> = P & {
                                                                                                                                                                                                                                                                                                                              autoPaginate?: boolean;
                                                                                                                                                                                                                                                                                                                              maxApiCalls?: number;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                type PagedResponse

                                                                                                                                                                                                                                                                                                                                type PagedResponse<T, Q, R> = [T[]] | [T[], Q | null, R];

                                                                                                                                                                                                                                                                                                                                  type PermissionsCallback

                                                                                                                                                                                                                                                                                                                                  type PermissionsCallback = RequestCallback<PermissionsResponse>;

                                                                                                                                                                                                                                                                                                                                    type PermissionsResponse

                                                                                                                                                                                                                                                                                                                                    type PermissionsResponse = [bigquery.ITestIamPermissionsResponse];

                                                                                                                                                                                                                                                                                                                                      type Policy

                                                                                                                                                                                                                                                                                                                                      type Policy = bigquery.IPolicy;

                                                                                                                                                                                                                                                                                                                                        type PolicyCallback

                                                                                                                                                                                                                                                                                                                                        type PolicyCallback = RequestCallback<PolicyResponse>;

                                                                                                                                                                                                                                                                                                                                          type PolicyRequest

                                                                                                                                                                                                                                                                                                                                          type PolicyRequest = bigquery.IGetIamPolicyRequest;

                                                                                                                                                                                                                                                                                                                                            type PolicyResponse

                                                                                                                                                                                                                                                                                                                                            type PolicyResponse = [Policy];

                                                                                                                                                                                                                                                                                                                                              type ProvidedTypeArray

                                                                                                                                                                                                                                                                                                                                              type ProvidedTypeArray = Array<ProvidedTypeStruct | string | []>;

                                                                                                                                                                                                                                                                                                                                                type Query

                                                                                                                                                                                                                                                                                                                                                type Query = JobRequest<bigquery.IJobConfigurationQuery> & {
                                                                                                                                                                                                                                                                                                                                                destination?: Table;
                                                                                                                                                                                                                                                                                                                                                params?:
                                                                                                                                                                                                                                                                                                                                                | any[]
                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                [param: string]: any;
                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                dryRun?: boolean;
                                                                                                                                                                                                                                                                                                                                                labels?: {
                                                                                                                                                                                                                                                                                                                                                [label: string]: string;
                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                types?: QueryParamTypes;
                                                                                                                                                                                                                                                                                                                                                job?: Job;
                                                                                                                                                                                                                                                                                                                                                maxResults?: number;
                                                                                                                                                                                                                                                                                                                                                jobTimeoutMs?: number;
                                                                                                                                                                                                                                                                                                                                                pageToken?: string;
                                                                                                                                                                                                                                                                                                                                                wrapIntegers?: boolean | IntegerTypeCastOptions;
                                                                                                                                                                                                                                                                                                                                                parseJSON?: boolean;
                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                  type QueryOptions

                                                                                                                                                                                                                                                                                                                                                  type QueryOptions = QueryResultsOptions;

                                                                                                                                                                                                                                                                                                                                                    type QueryParameter

                                                                                                                                                                                                                                                                                                                                                    type QueryParameter = bigquery.IQueryParameter;

                                                                                                                                                                                                                                                                                                                                                      type QueryResultsOptions

                                                                                                                                                                                                                                                                                                                                                      type QueryResultsOptions = {
                                                                                                                                                                                                                                                                                                                                                      job?: Job;
                                                                                                                                                                                                                                                                                                                                                      wrapIntegers?: boolean | IntegerTypeCastOptions;
                                                                                                                                                                                                                                                                                                                                                      parseJSON?: boolean;
                                                                                                                                                                                                                                                                                                                                                      } & PagedRequest<bigquery.jobs.IGetQueryResultsParams> & {
                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                      * internal properties
                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                      _cachedRows?: any[];
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        type QueryRowsCallback

                                                                                                                                                                                                                                                                                                                                                        type QueryRowsCallback = PagedCallback<
                                                                                                                                                                                                                                                                                                                                                        RowMetadata,
                                                                                                                                                                                                                                                                                                                                                        Query,
                                                                                                                                                                                                                                                                                                                                                        bigquery.IGetQueryResultsResponse
                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                          type QueryRowsResponse

                                                                                                                                                                                                                                                                                                                                                          type QueryRowsResponse = PagedResponse<
                                                                                                                                                                                                                                                                                                                                                          RowMetadata,
                                                                                                                                                                                                                                                                                                                                                          Query,
                                                                                                                                                                                                                                                                                                                                                          bigquery.IGetQueryResultsResponse
                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                            type QueryStreamOptions

                                                                                                                                                                                                                                                                                                                                                            type QueryStreamOptions = {
                                                                                                                                                                                                                                                                                                                                                            wrapIntegers?: boolean | IntegerTypeCastOptions;
                                                                                                                                                                                                                                                                                                                                                            parseJSON?: boolean;
                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                              type RoutineCallback

                                                                                                                                                                                                                                                                                                                                                              type RoutineCallback = ResourceCallback<Routine, bigquery.IRoutine>;

                                                                                                                                                                                                                                                                                                                                                                type RoutineMetadata

                                                                                                                                                                                                                                                                                                                                                                type RoutineMetadata = bigquery.IRoutine;

                                                                                                                                                                                                                                                                                                                                                                  type RoutineResponse

                                                                                                                                                                                                                                                                                                                                                                  type RoutineResponse = [Routine, bigquery.IRoutine];

                                                                                                                                                                                                                                                                                                                                                                    type RowMetadata

                                                                                                                                                                                                                                                                                                                                                                    type RowMetadata = any;

                                                                                                                                                                                                                                                                                                                                                                      type RowsCallback

                                                                                                                                                                                                                                                                                                                                                                      type RowsCallback = PagedCallback<
                                                                                                                                                                                                                                                                                                                                                                      RowMetadata,
                                                                                                                                                                                                                                                                                                                                                                      GetRowsOptions,
                                                                                                                                                                                                                                                                                                                                                                      bigquery.ITableDataList | bigquery.ITable
                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                        type RowsResponse

                                                                                                                                                                                                                                                                                                                                                                        type RowsResponse = PagedResponse<
                                                                                                                                                                                                                                                                                                                                                                        RowMetadata,
                                                                                                                                                                                                                                                                                                                                                                        GetRowsOptions,
                                                                                                                                                                                                                                                                                                                                                                        bigquery.ITableDataList | bigquery.ITable
                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                          type SetPolicyOptions

                                                                                                                                                                                                                                                                                                                                                                          type SetPolicyOptions = Omit<bigquery.ISetIamPolicyRequest, 'policy'>;

                                                                                                                                                                                                                                                                                                                                                                            type SetTableMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                            type SetTableMetadataOptions = TableMetadata;

                                                                                                                                                                                                                                                                                                                                                                              type SimpleQueryRowsCallback

                                                                                                                                                                                                                                                                                                                                                                              type SimpleQueryRowsCallback = ResourceCallback<RowMetadata[], bigquery.IJob>;

                                                                                                                                                                                                                                                                                                                                                                                type SimpleQueryRowsResponse

                                                                                                                                                                                                                                                                                                                                                                                type SimpleQueryRowsResponse = [RowMetadata[], bigquery.IJob];

                                                                                                                                                                                                                                                                                                                                                                                  type TableCallback

                                                                                                                                                                                                                                                                                                                                                                                  type TableCallback = ResourceCallback<Table, bigquery.ITable>;

                                                                                                                                                                                                                                                                                                                                                                                    type TableField

                                                                                                                                                                                                                                                                                                                                                                                    type TableField = bigquery.ITableFieldSchema;

                                                                                                                                                                                                                                                                                                                                                                                      type TableMetadata

                                                                                                                                                                                                                                                                                                                                                                                      type TableMetadata = bigquery.ITable & {
                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                      schema?: string | TableField[] | TableSchema;
                                                                                                                                                                                                                                                                                                                                                                                      partitioning?: string;
                                                                                                                                                                                                                                                                                                                                                                                      view?: string | ViewDefinition;
                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                        type TableResponse

                                                                                                                                                                                                                                                                                                                                                                                        type TableResponse = [Table, bigquery.ITable];

                                                                                                                                                                                                                                                                                                                                                                                          type TableRow

                                                                                                                                                                                                                                                                                                                                                                                          type TableRow = bigquery.ITableRow;

                                                                                                                                                                                                                                                                                                                                                                                            type TableRowField

                                                                                                                                                                                                                                                                                                                                                                                            type TableRowField = bigquery.ITableCell;

                                                                                                                                                                                                                                                                                                                                                                                              type TableRowValue

                                                                                                                                                                                                                                                                                                                                                                                              type TableRowValue = string | TableRow;

                                                                                                                                                                                                                                                                                                                                                                                                type TableSchema

                                                                                                                                                                                                                                                                                                                                                                                                type TableSchema = bigquery.ITableSchema;

                                                                                                                                                                                                                                                                                                                                                                                                  type ValueType

                                                                                                                                                                                                                                                                                                                                                                                                  type ValueType = bigquery.IQueryParameterType;

                                                                                                                                                                                                                                                                                                                                                                                                    type ViewDefinition

                                                                                                                                                                                                                                                                                                                                                                                                    type ViewDefinition = bigquery.IViewDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (9)

                                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (11)

                                                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (24)

                                                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@google-cloud/bigquery.

                                                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@google-cloud/bigquery)
                                                                                                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@google-cloud/bigquery"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>