tedious

constructor

constructor(
    table: string,
    collation: Collation,
    connectionOptions: InternalConnectionOptions,
    { checkConstraints, fireTriggers, keepNulls, lockTable, order }: Options,
    callback: Callback
);

property bulkOptions

bulkOptions: InternalOptions;

property callback

callback: Callback;

property canceled

canceled: boolean;

property collation

collation: Collation;

property columns

columns: Column[];

property columnsByName

columnsByName: { [name: string]: Column };

property connection

connection: Connection;

property error

error: Error;

property executionStarted

executionStarted: boolean;

property firstRowWritten

firstRowWritten: boolean;

property options

options: InternalConnectionOptions;

property rowCount

rowCount: number;

property rows

rows: any[];

property rowToPacketTransform

rowToPacketTransform: RowTransform;

property rst

rst: any[];

property streamingMode

streamingMode: boolean;

property table

table: string;

property timeout

timeout: number;

method addColumn

addColumn: (
    name: string,
    type: DataType,
    { output, length, precision, scale, objName, nullable }: ColumnOptions
) => void;

• Adds a column to the bulk load.

  The column definitions should match the table you are trying to insert into. Attempting to call addColumn after the first row has been added will throw an exception.

  bulkLoad.addColumn('MyIntColumn', TYPES.Int, { nullable: false });

  Parameter name

  The name of the column.

  Parameter type

  One of the supported data types.

  Parameter __namedParameters

  Additional column type information. At a minimum, nullable must be set to true or false.

  Parameter length

  For VarChar, NVarChar, VarBinary. Use length as Infinity for VarChar(max), NVarChar(max) and VarBinary(max).

  Parameter nullable

  Indicates whether the column accepts NULL values.

  Parameter objName

  If the name of the column is different from the name of the property found on rowObj arguments passed to [[addRow]] or [[Connection.execBulkLoad]], then you can use this option to specify the property name.

  Parameter precision

  For Numeric, Decimal.

  Parameter scale

  For Numeric, Decimal, Time, DateTime2, DateTimeOffset.

method cancel

cancel: () => void;

method createDoneToken

createDoneToken: () => Buffer;

method getBulkInsertSql

getBulkInsertSql: () => string;

method getColMetaData

getColMetaData: () => Buffer;

method getOptionsSql

getOptionsSql: () => string;

method getTableCreationSql

getTableCreationSql: () => string;

• This is simply a helper utility function which returns a CREATE TABLE SQL statement based on the columns added to the bulkLoad object. This may be particularly handy when you want to insert into a temporary table (a table which starts with #).

  var sql = bulkLoad.getTableCreationSql();

  A side note on bulk inserting into temporary tables: if you want to access a local temporary table after executing the bulk load, you'll need to use the same connection and execute your requests using [[Connection.execSqlBatch]] instead of [[Connection.execSql]]

method setTimeout

setTimeout: (timeout?: number) => void;

• Sets a timeout for this bulk load.

  bulkLoad.setTimeout(timeout);

  Parameter timeout

  The number of milliseconds before the bulk load is considered failed, or 0 for no timeout. When no timeout is set for the bulk load, the [[ConnectionOptions.requestTimeout]] of the Connection is used.

constructor

constructor(config: ConnectionConfiguration);

• Note: be aware of the different options field: 1. config.authentication.options 2. config.options

  const { Connection } = require('tedious');
  
  const config = {
   "authentication": {
     ...,
     "options": {...}
   },
   "options": {...}
  };
  
  const connection = new Connection(config);

  Parameter config

property cancelTimer

cancelTimer: any;

property closed

closed: boolean;

property config

config: InternalConnectionConfig;

property connectTimer

connectTimer: any;

property curTransientRetryCount

curTransientRetryCount: number;

property databaseCollation

databaseCollation: Collation;

property debug

debug: Debug;

property fedAuthRequired

fedAuthRequired: boolean;

property inTransaction

inTransaction: boolean;

property isSqlBatch

isSqlBatch: boolean;

property loginError

loginError: AggregateError | ConnectionError;

property messageBuffer

messageBuffer: Buffer;

property messageIo

messageIo: MessageIO;

property ntlmpacket

ntlmpacket: any;

property ntlmpacketBuffer

ntlmpacketBuffer: any;

property procReturnStatusValue

procReturnStatusValue: any;

property request

request: Request | BulkLoad;

property requestTimer

requestTimer: any;

property resetConnectionOnNextRequest

resetConnectionOnNextRequest: boolean;

property retryTimer

retryTimer: any;

property routingData

routingData: RoutingData;

property secureContextOptions

secureContextOptions: SecureContextOptions;

property socket

socket: any;

property state

state: State;

property STATE

STATE: {
    INITIALIZED: State;
    CONNECTING: State;
    SENT_PRELOGIN: State;
    REROUTING: State;
    TRANSIENT_FAILURE_RETRY: State;
    SENT_TLSSSLNEGOTIATION: State;
    SENT_LOGIN7_WITH_STANDARD_LOGIN: State;
    SENT_LOGIN7_WITH_NTLM: State;
    SENT_LOGIN7_WITH_FEDAUTH: State;
    LOGGED_IN_SENDING_INITIAL_SQL: State;
    LOGGED_IN: State;
    SENT_CLIENT_REQUEST: State;
    SENT_ATTENTION: State;
    FINAL: State;
};

property transactionDepth

transactionDepth: number;

property transactionDescriptors

transactionDescriptors: Buffer[];

property transientErrorLookup

transientErrorLookup: TransientErrorLookup;

method beginTransaction

beginTransaction: (
    callback: BeginTransactionCallback,
    name?: string,
    isolationLevel?: number
) => void;

• Start a transaction.

  Parameter callback

  Parameter name

  A string representing a name to associate with the transaction. Optional, and defaults to an empty string. Required when isolationLevel is present.

  Parameter isolationLevel

  The isolation level that the transaction is to be run with.

  The isolation levels are available from require('tedious').ISOLATION_LEVEL. * READ_UNCOMMITTED * READ_COMMITTED * REPEATABLE_READ * SERIALIZABLE * SNAPSHOT

  Optional, and defaults to the Connection's isolation level.

method callProcedure

callProcedure: (request: Request) => void;

• Call a stored procedure represented by [[Request]].

  Parameter request

  A [[Request]] object representing the request.

method cancel

cancel: () => boolean;

• Cancel currently executed request.

method cancelTimeout

cancelTimeout: () => void;

method cleanupConnection

cleanupConnection: (
    cleanupType: (typeof CLEANUP_TYPE)[keyof typeof CLEANUP_TYPE]
) => void;

method clearCancelTimer

clearCancelTimer: () => void;

method clearConnectTimer

clearConnectTimer: () => void;

method clearRequestTimer

clearRequestTimer: () => void;

method clearRetryTimer

clearRetryTimer: () => void;

method close

close: () => void;

• Closes the connection to the database.

  The [[Event_end]] will be emitted once the connection has been closed.

method closeConnection

closeConnection: () => void;

method commitTransaction

commitTransaction: (callback: CommitTransactionCallback, name?: string) => void;

• Commit a transaction.

  There should be an active transaction - that is, [[beginTransaction]] should have been previously called.

  Parameter callback

  Parameter name

  A string representing a name to associate with the transaction. Optional, and defaults to an empty string. Required when isolationLevelis present.

method connect

connect: (connectListener?: (err?: Error) => void) => void;

method connectOnPort

connectOnPort: (
    port: number,
    multiSubnetFailover: boolean,
    signal: AbortSignal,
    customConnector?: () => Promise<net.Socket>
) => void;

method connectTimeout

connectTimeout: () => void;

method createCancelTimer

createCancelTimer: () => void;

method createConnectTimer

createConnectTimer: () => AbortSignal;

method createDebug

createDebug: () => Debug;

method createRequestTimer

createRequestTimer: () => void;

method createRetryTimer

createRetryTimer: () => void;

method createTokenStreamParser

createTokenStreamParser: (
    message: Message,
    handler: TokenHandler
) => TokenStreamParser;

method currentTransactionDescriptor

currentTransactionDescriptor: () => Buffer;

method dispatchEvent

dispatchEvent: <
    T extends
        | 'retry'
        | 'socketError'
        | 'connectTimeout'
        | 'message'
        | 'reconnect'
>(
    eventName: T,
    ...args: Parameters<NonNullable<State['events'][T]>>
) => void;

method emit

emit: {
    (event: 'charsetChange', charset: string): boolean;
    (event: 'connect', error?: Error): boolean;
    (event: 'databaseChange', databaseName: string): boolean;
    (event: 'debug', messageText: string): boolean;
    (event: 'error', error: Error): boolean;
    (event: 'errorMessage', message: ErrorMessageToken): boolean;
    (event: 'end'): boolean;
    (event: 'infoMessage', message: InfoMessageToken): boolean;
    (event: 'languageChange', languageName: string): boolean;
    (event: 'secure', cleartext: any): boolean;
    (event: 'rerouting'): boolean;
    (event: 'resetConnection'): boolean;
    (event: 'retry'): boolean;
    (event: 'rollbackTransaction'): boolean;
};

method execBulkLoad

execBulkLoad: (
    bulkLoad: BulkLoad,
    rows:
        | AsyncIterable<unknown[] | { [columnName: string]: unknown }>
        | Iterable<unknown[] | { [columnName: string]: unknown }>
) => void;

• Execute a [[BulkLoad]].

  // We want to perform a bulk load into a table with the following format:
  // CREATE TABLE employees (first_name nvarchar(255), last_name nvarchar(255), day_of_birth date);
  
  const bulkLoad = connection.newBulkLoad('employees', (err, rowCount) => {
    // ...
  });
  
  // First, we need to specify the columns that we want to write to,
  // and their definitions. These definitions must match the actual table,
  // otherwise the bulk load will fail.
  bulkLoad.addColumn('first_name', TYPES.NVarchar, { nullable: false });
  bulkLoad.addColumn('last_name', TYPES.NVarchar, { nullable: false });
  bulkLoad.addColumn('date_of_birth', TYPES.Date, { nullable: false });
  
  // Execute a bulk load with a predefined list of rows.
  //
  // Note that these rows are held in memory until the
  // bulk load was performed, so if you need to write a large
  // number of rows (e.g. by reading from a CSV file),
  // passing an `AsyncIterable` is advisable to keep memory usage low.
  connection.execBulkLoad(bulkLoad, [
    { 'first_name': 'Steve', 'last_name': 'Jobs', 'day_of_birth': new Date('02-24-1955') },
    { 'first_name': 'Bill', 'last_name': 'Gates', 'day_of_birth': new Date('10-28-1955') }
  ]);

  Parameter bulkLoad

  A previously created [[BulkLoad]].

  Parameter rows

  A [[Iterable]] or [[AsyncIterable]] that contains the rows that should be bulk loaded.

method execSql

execSql: (request: Request) => void;

• Execute the SQL represented by [[Request]].

  As sp_executesql is used to execute the SQL, if the same SQL is executed multiples times using this function, the SQL Server query optimizer is likely to reuse the execution plan it generates for the first execution. This may also result in SQL server treating the request like a stored procedure which can result in the [[Event_doneInProc]] or [[Event_doneProc]] events being emitted instead of the [[Event_done]] event you might expect. Using [[execSqlBatch]] will prevent this from occurring but may have a negative performance impact.

  Beware of the way that scoping rules apply, and how they may [affect local temp tables](http://weblogs.sqlteam.com/mladenp/archive/2006/11/03/17197.aspx) If you're running in to scoping issues, then [[execSqlBatch]] may be a better choice. See also [issue #24](https://github.com/pekim/tedious/issues/24)

  Parameter request

  A [[Request]] object representing the request.

method execSqlBatch

execSqlBatch: (request: Request) => void;

• Execute the SQL batch represented by [[Request]]. There is no param support, and unlike [[Request.execSql]], it is not likely that SQL Server will reuse the execution plan it generates for the SQL.

  In almost all cases, [[Request.execSql]] will be a better choice.

  Parameter request

  A [[Request]] object representing the request.

method execute

execute: (request: Request, parameters?: { [key: string]: unknown }) => void;

• Execute previously prepared SQL, using the supplied parameters.

  Parameter request

  A previously prepared [[Request]].

  Parameter parameters

  An object whose names correspond to the names of parameters that were added to the [[Request]] before it was prepared. The object's values are passed as the parameters' values when the request is executed.

method getEventHandler

getEventHandler: <
    T extends
        | 'retry'
        | 'socketError'
        | 'connectTimeout'
        | 'message'
        | 'reconnect'
>(
    eventName: T
) => NonNullable<State['events'][T]>;

method getInitialSql

getInitialSql: () => string;

method getIsolationLevelText

getIsolationLevelText: (
    isolationLevel: (typeof ISOLATION_LEVEL)[keyof typeof ISOLATION_LEVEL]
) =>
    | 'read uncommitted'
    | 'repeatable read'
    | 'serializable'
    | 'snapshot'
    | 'read committed';

method initialiseConnection

initialiseConnection: () => void | Promise<void>;

method makeRequest

makeRequest: (
    request: Request | BulkLoad,
    packetType: number,
    payload: (Iterable<Buffer> | AsyncIterable<Buffer>) & {
        toString: (indent?: string) => string;
    }
) => void;

method newBulkLoad

newBulkLoad: {
    (table: string, callback: BulkLoadCallback): BulkLoad;
    (
        table: string,
        options: BulkLoadOptions,
        callback: BulkLoadCallback
    ): BulkLoad;
};

• Creates a new BulkLoad instance.

  Parameter table

  The name of the table to bulk-insert into.

  Parameter options

  A set of bulk load options.

method on

on: {
    (event: 'charsetChange', listener: (charset: string) => void): this;
    (event: 'connect', listener: (err: Error) => void): this;
    (event: 'databaseChange', listener: (databaseName: string) => void): this;
    (event: 'debug', listener: (messageText: string) => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (
        event: 'errorMessage',
        listener: (message: ErrorMessageToken) => void
    ): this;
    (event: 'end', listener: () => void): this;
    (event: 'infoMessage', listener: (message: InfoMessageToken) => void): this;
    (event: 'languageChange', listener: (languageName: string) => void): this;
    (event: 'resetConnection', listener: () => void): this;
    (event: 'secure', listener: (cleartext: any) => void): this;
};

• The server has reported that the charset has changed.

• The attempt to connect and validate has completed.

• The server has reported that the active database has changed. This may be as a result of a successful login, or a use statement.

• A debug message is available. It may be logged or ignored.

• Internal error occurs.

• The server has issued an error message.

• The connection has ended.

  This may be as a result of the client calling [[close]], the server closing the connection, or a network error.

• The server has issued an information message.

• The server has reported that the language has changed.

• The connection was reset.

• A secure connection has been established.

method prepare

prepare: (request: Request) => void;

• Prepare the SQL represented by the request.

  The request can then be used in subsequent calls to [[execute]] and [[unprepare]]

  Parameter request

  A [[Request]] object representing the request. Parameters only require a name and type. Parameter values are ignored.

method processedInitialSql

processedInitialSql: () => void;

method requestTimeout

requestTimeout: () => void;

method reset

reset: (callback: ResetCallback) => void;

• Reset the connection to its initial state. Can be useful for connection pool implementations.

  Parameter callback

method retryTimeout

retryTimeout: () => void;

method rollbackTransaction

rollbackTransaction: (
    callback: RollbackTransactionCallback,
    name?: string
) => void;

• Rollback a transaction.

  There should be an active transaction - that is, [[beginTransaction]] should have been previously called.

  Parameter callback

  Parameter name

  A string representing a name to associate with the transaction. Optional, and defaults to an empty string. Required when isolationLevel is present.

method saveTransaction

saveTransaction: (callback: SaveTransactionCallback, name: string) => void;

• Set a savepoint within a transaction.

  There should be an active transaction - that is, [[beginTransaction]] should have been previously called.

  Parameter callback

  Parameter name

  A string representing a name to associate with the transaction.\ Optional, and defaults to an empty string. Required when isolationLevel is present.

method sendFedAuthTokenMessage

sendFedAuthTokenMessage: (token: string) => void;

method sendInitialSql

sendInitialSql: () => void;

method sendLogin7Packet

sendLogin7Packet: () => void;

method sendPreLogin

sendPreLogin: () => void;

method socketClose

socketClose: () => void;

method socketEnd

socketEnd: () => void;

method socketError

socketError: (error: Error) => void;

method socketHandlingForSendPreLogin

socketHandlingForSendPreLogin: (socket: net.Socket) => void;

method transaction

transaction: (
    cb: (
        err: Error | null | undefined,
        txDone?: <T extends TransactionDoneCallback>(
            err: Error | null | undefined,
            done: T,
            ...args: CallbackParameters<T>
        ) => void
    ) => void,
    isolationLevel?: (typeof ISOLATION_LEVEL)[keyof typeof ISOLATION_LEVEL]
) => void;

• Run the given callback after starting a transaction, and commit or rollback the transaction afterwards.

  This is a helper that employs [[beginTransaction]], [[commitTransaction]], [[rollbackTransaction]], and [[saveTransaction]] to greatly simplify the use of database transactions and automatically handle transaction nesting.

  Parameter cb

  Parameter isolationLevel

  The isolation level that the transaction is to be run with.

  The isolation levels are available from require('tedious').ISOLATION_LEVEL. * READ_UNCOMMITTED * READ_COMMITTED * REPEATABLE_READ * SERIALIZABLE * SNAPSHOT

  Optional, and defaults to the Connection's isolation level.

method transitionTo

transitionTo: (newState: State) => void;

method unprepare

unprepare: (request: Request) => void;

• Release the SQL Server resources associated with a previously prepared request.

  Parameter request

  A [[Request]] object representing the request. Parameters only require a name and type. Parameter values are ignored.

method wrapWithTls

wrapWithTls: (socket: net.Socket, signal: AbortSignal) => Promise<tls.TLSSocket>;

constructor

constructor(message: string, code?: string);

property code

code: string;

property isTransient

isTransient: boolean;

constructor

constructor(
    sqlTextOrProcedure: string,
    callback: CompletionCallback,
    options?: RequestOptions
);

• Parameter sqlTextOrProcedure

  The SQL statement to be executed

  Parameter callback

  The callback to execute once the request has been fully completed.

property callback

callback: CompletionCallback;

property canceled

canceled: boolean;

property connection

connection: Connection;

property cryptoMetadataLoaded

cryptoMetadataLoaded: boolean;

property error

error: Error;

property handle

handle: number;

property parameters

parameters: Parameter[];

property parametersByName

parametersByName: { [key: string]: Parameter };

property paused

paused: boolean;

property preparing

preparing: boolean;

property rowCount

rowCount?: number;

property rows

rows?: any[];

property rst

rst?: any[];

property shouldHonorAE

shouldHonorAE?: boolean;

property sqlTextOrProcedure

sqlTextOrProcedure: string;

property statementColumnEncryptionSetting

statementColumnEncryptionSetting: SQLServerStatementColumnEncryptionSetting;

property timeout

timeout: number;

property userCallback

userCallback: CompletionCallback;

method addOutputParameter

addOutputParameter: (
    name: string,
    type: DataType,
    value?: unknown,
    options?: Readonly<ParameterOptions> | null
) => void;

• Parameter name

  The parameter name. This should correspond to a parameter in the SQL, or a parameter that a called procedure expects.

  Parameter type

  One of the supported data types.

  Parameter value

  The value that the parameter is to be given. The Javascript type of the argument should match that documented for data types

  Parameter options

  Additional type options. Optional.

method addParameter

addParameter: (
    name: string,
    type: DataType,
    value?: unknown,
    options?: Readonly<ParameterOptions> | null
) => void;

• Parameter name

  The parameter name. This should correspond to a parameter in the SQL, or a parameter that a called procedure expects. The name should not start with @.

  Parameter type

  One of the supported data types.

  Parameter value

  The value that the parameter is to be given. The Javascript type of the argument should match that documented for data types.

  Parameter options

  Additional type options. Optional.

method cancel

cancel: () => void;

• Cancels a request while waiting for a server response.

method emit

emit: {
    (
        event: 'columnMetadata',
        columns: ColumnMetadata[] | { [key: string]: ColumnMetadata }
    ): boolean;
    (event: 'prepared'): boolean;
    (event: 'error', err: Error): boolean;
    (event: 'row', columns: any): boolean;
    (event: 'done', rowCount: number, more: boolean, rst?: any[]): boolean;
    (event: 'doneInProc', rowCount: number, more: boolean, rst?: any[]): boolean;
    (
        event: 'doneProc',
        rowCount: number,
        more: boolean,
        procReturnStatusValue: number,
        rst?: any[]
    ): boolean;
    (
        event: 'returnValue',
        parameterName: string,
        value: unknown,
        metadata: Metadata
    ): boolean;
    (event: 'requestCompleted'): boolean;
    (event: 'cancel'): boolean;
    (event: 'pause'): boolean;
    (event: 'resume'): boolean;
    (event: 'order', orderColumns: number[]): boolean;
};

method makeParamsParameter

makeParamsParameter: (parameters: Parameter[]) => string;

method on

on: {
    (
        event: 'columnMetadata',
        listener: (
            columns: ColumnMetadata[] | { [key: string]: ColumnMetadata }
        ) => void
    ): this;
    (event: 'prepared', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'row', listener: (columns: any) => void): this;
    (
        event: 'done',
        listener: (rowCount: number, more: boolean, rst?: any[]) => void
    ): this;
    (
        event: 'doneInProc',
        listener: (rowCount: number, more: boolean, rst?: any[]) => void
    ): this;
    (
        event: 'doneProc',
        listener: (
            rowCount: number,
            more: boolean,
            procReturnStatusValue: number,
            rst?: any[]
        ) => void
    ): this;
    (
        event: 'returnValue',
        listener: (
            parameterName: string,
            value: unknown,
            metadata: Metadata
        ) => void
    ): this;
    (event: 'order', listener: (orderColumns: number[]) => void): this;
    (event: 'requestCompleted', listener: () => void): this;
    (event: 'cancel', listener: () => void): this;
    (event: 'pause', listener: () => void): this;
    (event: 'resume', listener: () => void): this;
};

• This event, describing result set columns, will be emitted before row events are emitted. This event may be emitted multiple times when more than one recordset is produced by the statement.

  An array like object, where the columns can be accessed either by index or name. Columns with a name that is an integer are not accessible by name, as it would be interpreted as an array index.

• The request has been prepared and can be used in subsequent calls to execute and unprepare.

• The request encountered an error and has not been prepared.

• A row resulting from execution of the SQL statement.

• All rows from a result set have been provided (through row events).

  This token is used to indicate the completion of a SQL statement. As multiple SQL statements can be sent to the server in a single SQL batch, multiple done can be generated. An done event is emitted for each SQL statement in the SQL batch except variable declarations. For execution of SQL statements within stored procedures, doneProc and doneInProc events are used in place of done.

  If you are using [[Connection.execSql]] then SQL server may treat the multiple calls with the same query as a stored procedure. When this occurs, the doneProc and doneInProc events may be emitted instead. You must handle both events to ensure complete coverage.

• request.on('doneInProc', function (rowCount, more, rows) { });

  Indicates the completion status of a SQL statement within a stored procedure. All rows from a statement in a stored procedure have been provided (through row events).

  This event may also occur when executing multiple calls with the same query using [[execSql]].

• Indicates the completion status of a stored procedure. This is also generated for stored procedures executed through SQL statements.\ This event may also occur when executing multiple calls with the same query using [[execSql]].

• A value for an output parameter (that was added to the request with [[addOutputParameter]]). See also Using Parameters.

• This event gives the columns by which data is ordered, if ORDER BY clause is executed in SQL Server.

method pause

pause: () => void;

• Temporarily suspends the flow of data from the database. No more row events will be emitted until [[resume] is called. If this request is already in a paused state, calling [[pause]] has no effect.

method resume

resume: () => void;

• Resumes the flow of data from the database. If this request is not in a paused state, calling [[resume]] has no effect.

method setTimeout

setTimeout: (timeout?: number) => void;

• Sets a timeout for this request.

  Parameter timeout

  The number of milliseconds before the request is considered failed, or 0 for no timeout. When no timeout is set for the request, the [[ConnectionOptions.requestTimeout]] of the [[Connection]] is used.

method validateParameters

validateParameters: (collation: Collation | undefined) => void;

constructor

constructor(message: string, code?: string);

property class

class: number;

property code