Class Dataset (7.7.0)

Package

Example

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

Constructors

(constructor)(bigQuery, id, options)

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

Properties

bigQuery

bigQuery: BigQuery;

location

location?: string;

projectId

projectId: string;

Methods

createQueryJob(options)

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

createQueryJob(options, callback)

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

createQueryStream(options)

createQueryStream(options: Query | string): Duplex;

createRoutine(id, config)

createRoutine(id: string, config: RoutineMetadata): Promise<RoutineResponse>;

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

If the callback is omitted a Promise will be returned

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

createRoutine(id, config, callback)

createRoutine(id: string, config: RoutineMetadata, callback: RoutineCallback): void;

createTable(id, options)

createTable(id: string, options: TableMetadata): Promise<TableResponse>;

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

createTable(id, options, callback)

createTable(id: string, options: TableMetadata, callback: TableCallback): void;

createTable(id, callback)

createTable(id: string, callback: TableCallback): void;

delete(options)

delete(options?: DatasetDeleteOptions): Promise<[Metadata]>;

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

delete(options, callback)

delete(options: DatasetDeleteOptions, callback: DeleteCallback): void;

delete(callback)

delete(callback: DeleteCallback): void;

getModels(options)

getModels(options?: GetModelsOptions): Promise<GetModelsResponse>;

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

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

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

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

getModels(options, callback)

getModels(options: GetModelsOptions, callback: GetModelsCallback): void;

getModels(callback)

getModels(callback: GetModelsCallback): void;

getModelsStream(options)

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

getRoutines(options)

getRoutines(options?: GetRoutinesOptions): Promise<GetRoutinesResponse>;

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

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

If the callback is omitted a Promise will be returned

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

getRoutines(options, callback)

getRoutines(options: GetRoutinesOptions, callback: GetRoutinesCallback): void;

getRoutines(callback)

getRoutines(callback: GetRoutinesCallback): void;

getRoutinesStream(options)

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

getTables(options)

getTables(options?: GetTablesOptions): Promise<GetTablesResponse>;

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

getTables(options, callback)

getTables(options: GetTablesOptions, callback: GetTablesCallback): void;

getTables(callback)

getTables(callback: GetTablesCallback): void;

getTablesStream(options)

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

model(id)

model(id: string): Model;

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

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

query(options)

query(options: Query): Promise<QueryRowsResponse>;

query(options)

query(options: string): Promise<QueryRowsResponse>;

query(options, callback)

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

query(options, callback)

query(options: string, callback: SimpleQueryRowsCallback): void;

routine(id)

routine(id: string): Routine;

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

const routine = dataset.routine('my_routine');

table(id, options)

table(id: string, options?: TableOptions): Table;

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

const institutions = dataset.table('institution_data');