Class Table (7.7.0)

Package

Example

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

const table = dataset.table('my-table');

Constructors

(constructor)(dataset, id, options)

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

Properties

bigQuery

bigQuery: BigQuery;

dataset

dataset: Dataset;

location

location?: string;

rowQueue

rowQueue?: RowQueue;

Methods

_createLoadJob(source, metadata)

_createLoadJob(source: string | File | File[], metadata: JobLoadMetadata): Promise<JobResponse>;

copy(destination, metadata)

copy(destination: Table, metadata?: CopyTableMetadata): Promise<JobMetadataResponse>;

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];
});

copy(destination, metadata, callback)

copy(destination: Table, metadata: CopyTableMetadata, callback: JobMetadataCallback): void;

copy(destination, callback)

copy(destination: Table, callback: JobMetadataCallback): void;

copyFrom(sourceTables, metadata)

copyFrom(sourceTables: Table | Table[], metadata?: CopyTableMetadata): Promise<JobMetadataResponse>;

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];
});

copyFrom(sourceTables, metadata, callback)

copyFrom(sourceTables: Table | Table[], metadata: CopyTableMetadata, callback: JobMetadataCallback): void;

copyFrom(sourceTables, callback)

copyFrom(sourceTables: Table | Table[], callback: JobMetadataCallback): void;

createCopyFromJob(source, metadata)

createCopyFromJob(source: Table | Table[], metadata?: CopyTableMetadata): Promise<JobResponse>;

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];
});

createCopyFromJob(source, metadata, callback)

createCopyFromJob(source: Table | Table[], metadata: CopyTableMetadata, callback: JobCallback): void;

createCopyFromJob(source, callback)

createCopyFromJob(source: Table | Table[], callback: JobCallback): void;

createCopyJob(destination, metadata)

createCopyJob(destination: Table, metadata?: CreateCopyJobMetadata): Promise<JobResponse>;

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];
});

createCopyJob(destination, metadata, callback)

createCopyJob(destination: Table, metadata: CreateCopyJobMetadata, callback: JobCallback): void;

createCopyJob(destination, callback)

createCopyJob(destination: Table, callback: JobCallback): void;

createExtractJob(destination, options)

createExtractJob(destination: File, options?: CreateExtractJobOptions): Promise<JobResponse>;

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];
});

createExtractJob(destination, options, callback)

createExtractJob(destination: File, options: CreateExtractJobOptions, callback: JobCallback): void;

createExtractJob(destination, callback)

createExtractJob(destination: File, callback: JobCallback): void;

createInsertStream(options)

createInsertStream(options?: InsertStreamOptions): Writable;

createLoadJob(source, metadata)

createLoadJob(source: string | File | File[], metadata?: JobLoadMetadata): Promise<JobResponse>;

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];
});

createLoadJob(source, metadata, callback)

createLoadJob(source: string | File | File[], metadata: JobLoadMetadata, callback: JobCallback): void;

createLoadJob(source, callback)

createLoadJob(source: string | File | File[], callback: JobCallback): void;

createQueryJob(options)

createQueryJob(options: Query): Promise<JobResponse>;

createQueryJob(options, callback)

createQueryJob(options: Query, callback: JobCallback): void;

createQueryStream(query)

createQueryStream(query: Query): Duplex;

createReadStream(options)

createReadStream(options?: GetRowsOptions): ResourceStream<RowMetadata>;

createSchemaFromString_(str)

static createSchemaFromString_(str: string): TableSchema;

createWriteStream_(metadata)

createWriteStream_(metadata: JobLoadMetadata | string): Writable;

createWriteStream(metadata)

createWriteStream(metadata: JobLoadMetadata | string): Writable;

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.
  });

encodeValue_(value)

static encodeValue_(value?: {} | null): {} | null;

extract(destination, options)

extract(destination: File, options?: CreateExtractJobOptions): Promise<JobMetadataResponse>;

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];
});

extract(destination, options, callback)

extract(destination: File, options: CreateExtractJobOptions, callback?: JobMetadataCallback): void;

extract(destination, callback)

extract(destination: File, callback?: JobMetadataCallback): void;

formatMetadata_(options)

static formatMetadata_(options: TableMetadata): FormattedMetadata;

getIamPolicy(optionsOrCallback)

getIamPolicy(optionsOrCallback?: GetPolicyOptions | PolicyCallback): Promise<PolicyResponse>;

getIamPolicy(options, callback)

getIamPolicy(options: GetPolicyOptions, callback: PolicyCallback): void;

getRows(options)

getRows(options?: GetRowsOptions): Promise<RowsResponse>;

getRows(options, callback)

getRows(options: GetRowsOptions, callback: RowsCallback): void;

getRows(callback)

getRows(callback: RowsCallback): void;

insert(rows, options)

insert(rows: RowMetadata | RowMetadata[], options?: InsertRowsOptions): Promise<InsertRowsResponse>;

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 specification.
//-
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 Troubleshooting Errors 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
    }
  });

insert(rows, options, callback)

insert(rows: RowMetadata | RowMetadata[], options: InsertRowsOptions, callback: InsertRowsCallback): void;

insert(rows, callback)

insert(rows: RowMetadata | RowMetadata[], callback: InsertRowsCallback): void;

load(source, metadata)

load(source: string | File | File[], metadata?: JobLoadMetadata): Promise<JobMetadataResponse>;

load(source, metadata, callback)

load(source: string | File | File[], metadata: JobLoadMetadata, callback: JobMetadataCallback): void;

load(source, callback)

load(source: string | File | File[], callback: JobMetadataCallback): void;

load(source, metadata)

load(source: string | File | File[], metadata?: JobLoadMetadata): Promise<JobMetadataResponse>;

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];
});

load(source, metadata, callback)

load(source: string | File | File[], metadata: JobLoadMetadata, callback: JobMetadataCallback): void;

load(source, callback)

load(source: string | File | File[], callback: JobMetadataCallback): void;

query(query)

query(query: Query): Promise<SimpleQueryRowsResponse>;

query(query)

query(query: string): Promise<SimpleQueryRowsResponse>;

query(query, callback)

query(query: Query, callback: SimpleQueryRowsCallback): void;

setIamPolicy(policy, options)

setIamPolicy(policy: Policy, options?: SetPolicyOptions): Promise<PolicyResponse>;

setIamPolicy(policy, options, callback)

setIamPolicy(policy: Policy, options: SetPolicyOptions, callback: PolicyCallback): void;

setIamPolicy(policy, callback)

setIamPolicy(policy: Policy, callback: PolicyCallback): void;

setMetadata(metadata)

setMetadata(metadata: SetTableMetadataOptions): Promise<SetMetadataResponse>;

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];
});

setMetadata(metadata, callback)

setMetadata(metadata: SetTableMetadataOptions, callback: ResponseCallback): void;

testIamPermissions(permissions)

testIamPermissions(permissions: string | string[]): Promise<PermissionsResponse>;

testIamPermissions(permissions, callback)

testIamPermissions(permissions: string | string[], callback: PermissionsCallback): void;