Class Database

Stay organized with collections Save and categorize content based on your preferences.

constructor(instance: Instance, name: string, poolOptions?: SessionPoolConstructor | SessionPoolOptions, queryOptions?: spannerClient.spanner.v1.ExecuteSqlRequest.IQueryOptions);

formattedName_: string;

pool_: SessionPoolInterface;

queryOptions_?: spannerClient.spanner.v1.ExecuteSqlRequest.IQueryOptions;

request: DatabaseRequest;

resourceHeader_: {
        [k: string]: string;
    };

_runPartitionedUpdate(session: Session, query: string | ExecuteSqlRequest, callback?: RunUpdateCallback): void | Promise<number>;

batchCreateSessions(options: number | BatchCreateSessionsOptions): Promise<BatchCreateSessionsResponse>;

batchCreateSessions(options: number | BatchCreateSessionsOptions, callback: BatchCreateSessionsCallback): void;

batchTransaction(identifier: TransactionIdentifier, options?: TimestampBounds): BatchTransaction;

close(callback: SessionPoolCloseCallback): void;

close(): Promise<DatabaseCloseResponse>;

createBatchTransaction(options?: TimestampBounds): Promise<CreateBatchTransactionResponse>;

createBatchTransaction(callback: CreateBatchTransactionCallback): void;

createBatchTransaction(options: TimestampBounds, callback: CreateBatchTransactionCallback): void;

createSession(options: CreateSessionOptions): Promise<CreateSessionResponse>;

createSession(callback: CreateSessionCallback): void;

createSession(options: CreateSessionOptions, callback: CreateSessionCallback): void;

createTable(schema: Schema, gaxOptions?: CallOptions): Promise<CreateTableResponse>;

createTable(schema: Schema, callback: CreateTableCallback): void;

createTable(schema: Schema, gaxOptions: CallOptions, callback: CreateTableCallback): void;

delete(gaxOptions?: CallOptions): Promise<DatabaseDeleteResponse>;

delete(callback: DatabaseDeleteCallback): void;

delete(gaxOptions: CallOptions, callback: DatabaseDeleteCallback): void;

exists(gaxOptions?: CallOptions): Promise<[boolean]>;

exists(callback: ExistsCallback): void;

exists(gaxOptions: CallOptions, callback: ExistsCallback): void;

static formatName_(instanceName: string, name: string): string;

get(options?: GetDatabaseConfig): Promise<DatabaseResponse>;

get(callback: DatabaseCallback): void;

get(options: GetDatabaseConfig, callback: DatabaseCallback): void;

static getEnvironmentQueryOptions(): databaseAdmin.spanner.v1.ExecuteSqlRequest.IQueryOptions;

getMetadata(gaxOptions?: CallOptions): Promise<GetDatabaseMetadataResponse>;

getMetadata(callback: GetDatabaseMetadataCallback): void;

getMetadata(gaxOptions: CallOptions, callback: GetDatabaseMetadataCallback): void;

getOperations(options?: GetDatabaseOperationsOptions): Promise<GetDatabaseOperationsResponse>;

getOperations(callback: GetDatabaseOperationsCallback): void;

getOperations(options: GetDatabaseOperationsOptions, callback: GetDatabaseOperationsCallback): void;

getRestoreInfo(options?: CallOptions): Promise<IRestoreInfoTranslatedEnum | undefined>;

getRestoreInfo(callback: GetRestoreInfoCallback): void;

getRestoreInfo(options: CallOptions, callback: GetRestoreInfoCallback): void;

getSchema(options?: CallOptions): Promise<GetSchemaResponse>;

getSchema(callback: GetSchemaCallback): void;

getSchema(options: CallOptions, callback: GetSchemaCallback): void;

getSessions(options?: GetSessionsOptions): Promise<GetSessionsResponse>;

getSessions(callback: GetSessionsCallback): void;

getSessions(options: GetSessionsOptions, callback: GetSessionsCallback): void;

getSessionsStream(options?: GetSessionsOptions): NodeJS.ReadableStream;

getSnapshot(options?: TimestampBounds): Promise<[Snapshot]>;

getSnapshot(callback: GetSnapshotCallback): void;

getSnapshot(options: TimestampBounds, callback: GetSnapshotCallback): void;

getState(options?: CallOptions): Promise<EnumKey<typeof databaseAdmin.spanner.admin.database.v1.Database.State> | undefined>;

getState(callback: GetStateCallback): void;

getState(options: CallOptions, callback: GetStateCallback): void;

getTransaction(): Promise<[Transaction]>;

getTransaction(callback: GetTransactionCallback): void;

makePooledRequest_(config: RequestConfig): Promise<Session>;

makePooledRequest_(config: RequestConfig, callback: PoolRequestCallback): void;

makePooledStreamingRequest_(config: RequestConfig): Readable;

restore(backupPath: string): Promise<RestoreDatabaseResponse>;

restore(backupPath: string, options?: RestoreOptions | CallOptions): Promise<RestoreDatabaseResponse>;

restore(backupPath: string, callback: RestoreDatabaseCallback): void;

restore(backupPath: string, options: RestoreOptions | CallOptions, callback: RestoreDatabaseCallback): void;

run(query: string | ExecuteSqlRequest): Promise<RunResponse>;

run(query: string | ExecuteSqlRequest, options?: TimestampBounds): Promise<RunResponse>;

run(query: string | ExecuteSqlRequest, callback: RunCallback): void;

run(query: string | ExecuteSqlRequest, options: TimestampBounds, callback: RunCallback): void;

runPartitionedUpdate(query: string | ExecuteSqlRequest): Promise<[number]>;

runPartitionedUpdate(query: string | ExecuteSqlRequest, callback?: RunUpdateCallback): void;

runStream(query: string | ExecuteSqlRequest, options?: TimestampBounds): PartialResultStream;

runTransaction(runFn: RunTransactionCallback): void;

runTransaction(options: RunTransactionOptions, runFn: RunTransactionCallback): void;

runTransactionAsync<T = {}>(runFn: AsyncRunTransactionCallback<T>): Promise<T>;

runTransactionAsync<T = {}>(options: RunTransactionOptions, runFn: AsyncRunTransactionCallback<T>): Promise<T>;

session(name?: string): Session;

table(name: string): Table;

updateSchema(statements: Schema, gaxOptions?: CallOptions): Promise<UpdateSchemaResponse>;

updateSchema(statements: Schema, callback: UpdateSchemaCallback): void;

updateSchema(statements: Schema, gaxOptions: CallOptions, callback: UpdateSchemaCallback): void;