@types/mssql

  • Version 9.1.0
  • Published
  • 22.1 kB
  • 3 dependencies
  • MIT license

Install

npm i @types/mssql
yarn add @types/mssql
pnpm add @types/mssql

Overview

TypeScript definitions for mssql

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable BigInt

var BigInt: ISqlTypeFactoryWithNoParams;

    variable Binary

    var Binary: ISqlTypeFactoryWithNoParams;

      variable Bit

      var Bit: ISqlTypeFactoryWithNoParams;

        variable Char

        var Char: ISqlTypeFactoryWithLength;

          variable Date

          var Date: ISqlTypeFactoryWithNoParams;

            variable DateTime

            var DateTime: ISqlTypeFactoryWithNoParams;

              variable DateTime2

              var DateTime2: ISqlTypeFactoryWithScale;

                variable DateTimeOffset

                var DateTimeOffset: ISqlTypeFactoryWithScale;

                  variable Decimal

                  var Decimal: ISqlTypeFactoryWithPrecisionScale;

                    variable DRIVERS

                    var DRIVERS: string[];

                      variable fix

                      var fix: boolean;

                        variable Float

                        var Float: ISqlTypeFactoryWithNoParams;

                          variable Geography

                          var Geography: ISqlTypeFactoryWithNoParams;

                            variable Geometry

                            var Geometry: ISqlTypeFactoryWithNoParams;

                              variable Image

                              var Image: ISqlTypeFactoryWithNoParams;

                                variable Int

                                var Int: ISqlTypeFactoryWithNoParams;

                                  variable ISOLATION_LEVEL

                                  var ISOLATION_LEVEL: {
                                  READ_UNCOMMITTED: IIsolationLevel;
                                  READ_COMMITTED: IIsolationLevel;
                                  REPEATABLE_READ: IIsolationLevel;
                                  SERIALIZABLE: IIsolationLevel;
                                  SNAPSHOT: IIsolationLevel;
                                  };

                                    variable map

                                    var map: IMap;

                                      variable MAX

                                      var MAX: number;

                                        variable Money

                                        var Money: ISqlTypeFactoryWithNoParams;

                                          variable NChar

                                          var NChar: ISqlTypeFactoryWithLength;

                                            variable NText

                                            var NText: ISqlTypeFactoryWithNoParams;

                                              variable Numeric

                                              var Numeric: ISqlTypeFactoryWithPrecisionScale;

                                                variable NVarChar

                                                var NVarChar: ISqlTypeFactoryWithLength;

                                                  variable pool

                                                  var pool: ConnectionPool;

                                                    variable Promise

                                                    var Promise: any;

                                                      variable Real

                                                      var Real: ISqlTypeFactoryWithNoParams;

                                                        variable SmallDateTime

                                                        var SmallDateTime: ISqlTypeFactoryWithNoParams;

                                                          variable SmallInt

                                                          var SmallInt: ISqlTypeFactoryWithNoParams;

                                                            variable SmallMoney

                                                            var SmallMoney: ISqlTypeFactoryWithNoParams;

                                                              variable Text

                                                              var Text: ISqlTypeFactoryWithNoParams;

                                                                variable Time

                                                                var Time: ISqlTypeFactoryWithScale;

                                                                  variable TinyInt

                                                                  var TinyInt: ISqlTypeFactoryWithNoParams;

                                                                    variable TVP

                                                                    var TVP: ISqlTypeFactoryWithTvpType;

                                                                      variable TYPES

                                                                      var TYPES: {
                                                                      VarChar: ISqlTypeFactoryWithLength;
                                                                      NVarChar: ISqlTypeFactoryWithLength;
                                                                      Text: ISqlTypeFactoryWithNoParams;
                                                                      Int: ISqlTypeFactoryWithNoParams;
                                                                      BigInt: ISqlTypeFactoryWithNoParams;
                                                                      TinyInt: ISqlTypeFactoryWithNoParams;
                                                                      SmallInt: ISqlTypeFactoryWithNoParams;
                                                                      Bit: ISqlTypeFactoryWithNoParams;
                                                                      Float: ISqlTypeFactoryWithNoParams;
                                                                      Numeric: ISqlTypeFactoryWithPrecisionScale;
                                                                      Decimal: ISqlTypeFactoryWithPrecisionScale;
                                                                      Real: ISqlTypeFactoryWithNoParams;
                                                                      Date: ISqlTypeFactoryWithNoParams;
                                                                      DateTime: ISqlTypeFactoryWithNoParams;
                                                                      DateTime2: ISqlTypeFactoryWithScale;
                                                                      DateTimeOffset: ISqlTypeFactoryWithScale;
                                                                      SmallDateTime: ISqlTypeFactoryWithNoParams;
                                                                      Time: ISqlTypeFactoryWithScale;
                                                                      UniqueIdentifier: ISqlTypeFactoryWithNoParams;
                                                                      SmallMoney: ISqlTypeFactoryWithNoParams;
                                                                      Money: ISqlTypeFactoryWithNoParams;
                                                                      Binary: ISqlTypeFactoryWithNoParams;
                                                                      VarBinary: ISqlTypeFactoryWithLength;
                                                                      Image: ISqlTypeFactoryWithNoParams;
                                                                      Xml: ISqlTypeFactoryWithNoParams;
                                                                      Char: ISqlTypeFactoryWithLength;
                                                                      NChar: ISqlTypeFactoryWithLength;
                                                                      NText: ISqlTypeFactoryWithNoParams;
                                                                      TVP: ISqlTypeFactoryWithTvpType;
                                                                      UDT: ISqlTypeFactoryWithNoParams;
                                                                      Geography: ISqlTypeFactoryWithNoParams;
                                                                      Geometry: ISqlTypeFactoryWithNoParams;
                                                                      Variant: ISqlTypeFactoryWithNoParams;
                                                                      };

                                                                        variable UDT

                                                                        var UDT: ISqlTypeFactoryWithNoParams;

                                                                          variable UniqueIdentifier

                                                                          var UniqueIdentifier: ISqlTypeFactoryWithNoParams;

                                                                            variable VarBinary

                                                                            var VarBinary: ISqlTypeFactoryWithLength;

                                                                              variable VarChar

                                                                              var VarChar: ISqlTypeFactoryWithLength;

                                                                                variable Variant

                                                                                var Variant: ISqlTypeFactoryWithNoParams;

                                                                                  variable Xml

                                                                                  var Xml: ISqlTypeFactoryWithNoParams;

                                                                                    Functions

                                                                                    function connect

                                                                                    connect: {
                                                                                    (config: config | string): Promise<ConnectionPool>;
                                                                                    (config: string | config, callback?: (err?: Error) => void): void;
                                                                                    };
                                                                                    • Open global connection pool.

                                                                                      Parameter config

                                                                                      Connection configuration object or connection string

                                                                                    • Open global connection pool.

                                                                                      Parameter config

                                                                                      Connection configuration object or connection string.

                                                                                      Parameter callback

                                                                                      A callback which is called after connection has established, or an error has occurred

                                                                                    function query

                                                                                    query: {
                                                                                    (command: string): Promise<IResult<any>>;
                                                                                    (command: TemplateStringsArray, ...interpolations: any[]): Promise<IResult<any>>;
                                                                                    <Entity>(command: string): Promise<IResult<Entity>>;
                                                                                    <Entity>(command: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                    IResult<Entity>
                                                                                    >;
                                                                                    <Entity>(
                                                                                    command: string,
                                                                                    callback: (err?: Error, recordset?: IResult<Entity>) => void
                                                                                    ): void;
                                                                                    };

                                                                                      Classes

                                                                                      class columns

                                                                                      class columns extends Array<IColumn> {}

                                                                                        method add

                                                                                        add: (
                                                                                        name: string,
                                                                                        type: (() => ISqlType) | ISqlType,
                                                                                        options?: IColumnOptions
                                                                                        ) => number;

                                                                                          class ConnectionError

                                                                                          class ConnectionError extends MSSQLError {}

                                                                                            class ConnectionPool

                                                                                            class ConnectionPool extends events.EventEmitter {}

                                                                                              constructor

                                                                                              public constructor(config: config, callback?: (err?: any) => void);

                                                                                                constructor

                                                                                                public constructor(connectionString: string, callback?: (err?: any) => void);

                                                                                                  property available

                                                                                                  readonly available: number;

                                                                                                    property borrowed

                                                                                                    readonly borrowed: number;

                                                                                                      property connected

                                                                                                      readonly connected: boolean;

                                                                                                        property connecting

                                                                                                        readonly connecting: boolean;

                                                                                                          property driver

                                                                                                          readonly driver: string;

                                                                                                            property healthy

                                                                                                            readonly healthy: boolean;

                                                                                                              property pending

                                                                                                              readonly pending: number;

                                                                                                                property pool

                                                                                                                readonly pool: Pool<tds.Connection>;

                                                                                                                  property size

                                                                                                                  readonly size: number;

                                                                                                                    method batch

                                                                                                                    batch: {
                                                                                                                    (batch: string): Promise<IResult<any>>;
                                                                                                                    (strings: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                    IResult<any>
                                                                                                                    >;
                                                                                                                    (
                                                                                                                    batch: string,
                                                                                                                    callback: (err?: Error, recordset?: IResult<any>) => void
                                                                                                                    ): void;
                                                                                                                    <Entity>(batch: string): Promise<IResult<Entity>>;
                                                                                                                    <Entity>(strings: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                    IResult<Entity>
                                                                                                                    >;
                                                                                                                    };

                                                                                                                      method close

                                                                                                                      close: { (): Promise<void>; (callback: (err: any) => void): void };

                                                                                                                        method connect

                                                                                                                        connect: { (): Promise<ConnectionPool>; (callback: (err: any) => void): void };

                                                                                                                          method parseConnectionString

                                                                                                                          static parseConnectionString: (
                                                                                                                          connectionString: string
                                                                                                                          ) => config & { options: IOptions; pool: Partial<PoolOpts<Connection>> };

                                                                                                                            method query

                                                                                                                            query: {
                                                                                                                            (command: string): Promise<IResult<any>>;
                                                                                                                            (strings: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                            IResult<any>
                                                                                                                            >;
                                                                                                                            <Entity>(command: string): Promise<IResult<Entity>>;
                                                                                                                            <Entity>(strings: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                            IResult<Entity>
                                                                                                                            >;
                                                                                                                            <Entity>(
                                                                                                                            command: string,
                                                                                                                            callback: (err?: Error, recordset?: IResult<Entity>) => void
                                                                                                                            ): void;
                                                                                                                            };

                                                                                                                              method request

                                                                                                                              request: () => Request;

                                                                                                                                method transaction

                                                                                                                                transaction: () => Transaction;

                                                                                                                                  class MSSQLError

                                                                                                                                  class MSSQLError extends Error {}

                                                                                                                                    constructor

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

                                                                                                                                      property code

                                                                                                                                      code: string;

                                                                                                                                        property name

                                                                                                                                        name: string;

                                                                                                                                          property originalError

                                                                                                                                          originalError?: Error;

                                                                                                                                            class PreparedStatement

                                                                                                                                            class PreparedStatement extends events.EventEmitter {}

                                                                                                                                              constructor

                                                                                                                                              public constructor(connection?: ConnectionPool);

                                                                                                                                                constructor

                                                                                                                                                public constructor(transaction: Transaction);

                                                                                                                                                  property parameters

                                                                                                                                                  parameters: IRequestParameters;

                                                                                                                                                    property prepared

                                                                                                                                                    prepared: boolean;

                                                                                                                                                      property statement

                                                                                                                                                      statement: string;

                                                                                                                                                        property stream

                                                                                                                                                        stream: any;

                                                                                                                                                          property transaction

                                                                                                                                                          transaction: Transaction;

                                                                                                                                                            method execute

                                                                                                                                                            execute: {
                                                                                                                                                            (values: Object): Promise<IProcedureResult<any>>;
                                                                                                                                                            <Entity>(values: Object): Promise<IProcedureResult<Entity>>;
                                                                                                                                                            (
                                                                                                                                                            values: Object,
                                                                                                                                                            callback: (err?: Error, result?: IProcedureResult<any>) => void
                                                                                                                                                            ): Request;
                                                                                                                                                            <Entity>(
                                                                                                                                                            values: Object,
                                                                                                                                                            callback: (err?: Error, result?: IProcedureResult<Entity>) => void
                                                                                                                                                            ): Request;
                                                                                                                                                            };

                                                                                                                                                              method input

                                                                                                                                                              input: (name: string, type: (() => ISqlType) | ISqlType) => PreparedStatement;

                                                                                                                                                                method output

                                                                                                                                                                output: (name: string, type: (() => ISqlType) | ISqlType) => PreparedStatement;

                                                                                                                                                                  method prepare

                                                                                                                                                                  prepare: {
                                                                                                                                                                  (statement?: string): Promise<void>;
                                                                                                                                                                  (statement?: string, callback?: (err?: Error) => void): PreparedStatement;
                                                                                                                                                                  };

                                                                                                                                                                    method unprepare

                                                                                                                                                                    unprepare: {
                                                                                                                                                                    (): Promise<void>;
                                                                                                                                                                    (callback: (err?: Error) => void): PreparedStatement;
                                                                                                                                                                    };

                                                                                                                                                                      class PreparedStatementError

                                                                                                                                                                      class PreparedStatementError extends MSSQLError {}

                                                                                                                                                                        class Request

                                                                                                                                                                        class Request extends events.EventEmitter {}

                                                                                                                                                                          constructor

                                                                                                                                                                          public constructor(connection?: ConnectionPool);

                                                                                                                                                                            constructor

                                                                                                                                                                            public constructor(transaction: Transaction);

                                                                                                                                                                              constructor

                                                                                                                                                                              public constructor(preparedStatement: PreparedStatement);

                                                                                                                                                                                property canceled

                                                                                                                                                                                canceled: boolean;

                                                                                                                                                                                  property multiple

                                                                                                                                                                                  multiple: boolean;

                                                                                                                                                                                    property parameters

                                                                                                                                                                                    parameters: IRequestParameters;

                                                                                                                                                                                      property pstatement

                                                                                                                                                                                      pstatement: PreparedStatement;

                                                                                                                                                                                        property stream

                                                                                                                                                                                        stream: any;

                                                                                                                                                                                          property transaction

                                                                                                                                                                                          transaction: Transaction;

                                                                                                                                                                                            property verbose

                                                                                                                                                                                            verbose: boolean;

                                                                                                                                                                                              method batch

                                                                                                                                                                                              batch: {
                                                                                                                                                                                              (batch: string): Promise<IResult<any>>;
                                                                                                                                                                                              (strings: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                                                                                              IResult<any>
                                                                                                                                                                                              >;
                                                                                                                                                                                              (
                                                                                                                                                                                              batch: string,
                                                                                                                                                                                              callback: (err?: Error, recordset?: IResult<any>) => void
                                                                                                                                                                                              ): void;
                                                                                                                                                                                              <Entity>(batch: string): Promise<IResult<Entity>>;
                                                                                                                                                                                              <Entity>(strings: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                                                                                              IResult<Entity>
                                                                                                                                                                                              >;
                                                                                                                                                                                              <Entity>(
                                                                                                                                                                                              batch: string,
                                                                                                                                                                                              callback: (err?: any, recordset?: IResult<Entity>) => void
                                                                                                                                                                                              ): void;
                                                                                                                                                                                              };

                                                                                                                                                                                                method bulk

                                                                                                                                                                                                bulk: {
                                                                                                                                                                                                (table: Table): Promise<IBulkResult>;
                                                                                                                                                                                                (table: Table, options: IBulkOptions): Promise<IBulkResult>;
                                                                                                                                                                                                (table: Table, callback: (err: Error, result: IBulkResult) => void): void;
                                                                                                                                                                                                (
                                                                                                                                                                                                table: Table,
                                                                                                                                                                                                options: IBulkOptions,
                                                                                                                                                                                                callback: (err: Error, result: IBulkResult) => void
                                                                                                                                                                                                ): void;
                                                                                                                                                                                                };

                                                                                                                                                                                                  method cancel

                                                                                                                                                                                                  cancel: () => void;

                                                                                                                                                                                                    method execute

                                                                                                                                                                                                    execute: {
                                                                                                                                                                                                    (procedure: string): Promise<IProcedureResult<any>>;
                                                                                                                                                                                                    <Entity>(procedure: string): Promise<IProcedureResult<Entity>>;
                                                                                                                                                                                                    <Entity>(
                                                                                                                                                                                                    procedure: string,
                                                                                                                                                                                                    callback: (
                                                                                                                                                                                                    err?: any,
                                                                                                                                                                                                    recordsets?: IProcedureResult<Entity>,
                                                                                                                                                                                                    returnValue?: any
                                                                                                                                                                                                    ) => void
                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                    };

                                                                                                                                                                                                      method input

                                                                                                                                                                                                      input: {
                                                                                                                                                                                                      (name: string, value: any): Request;
                                                                                                                                                                                                      (name: string, type: ISqlType | (() => ISqlType), value: any): Request;
                                                                                                                                                                                                      };

                                                                                                                                                                                                        method output

                                                                                                                                                                                                        output: (
                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                        type: (() => ISqlType) | ISqlType,
                                                                                                                                                                                                        value?: any
                                                                                                                                                                                                        ) => Request;

                                                                                                                                                                                                          method pause

                                                                                                                                                                                                          pause: () => boolean;

                                                                                                                                                                                                            method pipe

                                                                                                                                                                                                            pipe: (stream: NodeJS.WritableStream) => NodeJS.WritableStream;

                                                                                                                                                                                                              method query

                                                                                                                                                                                                              query: {
                                                                                                                                                                                                              (command: string): Promise<IResult<any>>;
                                                                                                                                                                                                              (command: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                                                                                                              IResult<any>
                                                                                                                                                                                                              >;
                                                                                                                                                                                                              <Entity>(command: string): Promise<IResult<Entity>>;
                                                                                                                                                                                                              <Entity>(command: TemplateStringsArray, ...interpolations: any[]): Promise<
                                                                                                                                                                                                              IResult<Entity>
                                                                                                                                                                                                              >;
                                                                                                                                                                                                              <Entity>(
                                                                                                                                                                                                              command: string,
                                                                                                                                                                                                              callback: (err?: Error, recordset?: IResult<Entity>) => void
                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method replaceInput

                                                                                                                                                                                                                replaceInput: {
                                                                                                                                                                                                                (name: string, value: any): Request;
                                                                                                                                                                                                                (name: string, type: ISqlType | (() => ISqlType), value: any): Request;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method resume

                                                                                                                                                                                                                  resume: () => boolean;

                                                                                                                                                                                                                    method toReadableStream

                                                                                                                                                                                                                    toReadableStream: (streamOptions?: ReadableOptions) => Readable;

                                                                                                                                                                                                                      class RequestError

                                                                                                                                                                                                                      class RequestError extends MSSQLError {}

                                                                                                                                                                                                                        property class

                                                                                                                                                                                                                        class?: string;

                                                                                                                                                                                                                          property lineNumber

                                                                                                                                                                                                                          lineNumber?: number;

                                                                                                                                                                                                                            property number

                                                                                                                                                                                                                            number?: number;

                                                                                                                                                                                                                              property procName

                                                                                                                                                                                                                              procName?: string;

                                                                                                                                                                                                                                property serverName

                                                                                                                                                                                                                                serverName?: string;

                                                                                                                                                                                                                                  property state

                                                                                                                                                                                                                                  state?: string;

                                                                                                                                                                                                                                    class rows

                                                                                                                                                                                                                                    class rows extends Array<IRow> {}

                                                                                                                                                                                                                                      method add

                                                                                                                                                                                                                                      add: (...row: IRow) => number;

                                                                                                                                                                                                                                        class Table

                                                                                                                                                                                                                                        class Table {}

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          public constructor(tableName?: string);

                                                                                                                                                                                                                                            property columns

                                                                                                                                                                                                                                            columns: columns;

                                                                                                                                                                                                                                              property create

                                                                                                                                                                                                                                              create: boolean;

                                                                                                                                                                                                                                                property database

                                                                                                                                                                                                                                                database?: string;

                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                    path?: string;

                                                                                                                                                                                                                                                      property rows

                                                                                                                                                                                                                                                      rows: rows;

                                                                                                                                                                                                                                                        property schema

                                                                                                                                                                                                                                                        schema?: string;

                                                                                                                                                                                                                                                          property temporary

                                                                                                                                                                                                                                                          temporary?: boolean;

                                                                                                                                                                                                                                                            class Transaction

                                                                                                                                                                                                                                                            class Transaction extends events.EventEmitter {}

                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                              public constructor(connection?: ConnectionPool);

                                                                                                                                                                                                                                                                property isolationLevel

                                                                                                                                                                                                                                                                isolationLevel: number;

                                                                                                                                                                                                                                                                  method begin

                                                                                                                                                                                                                                                                  begin: {
                                                                                                                                                                                                                                                                  (isolationLevel?: IIsolationLevel): Promise<Transaction>;
                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                  isolationLevel?: number,
                                                                                                                                                                                                                                                                  callback?: (err?: ConnectionError | TransactionError) => void
                                                                                                                                                                                                                                                                  ): Transaction;
                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                  • Begin a transaction.

                                                                                                                                                                                                                                                                    Parameter isolationLevel

                                                                                                                                                                                                                                                                    Controls the locking and row versioning behavior of TSQL statements issued by a connection.

                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                    A callback which is called after transaction has began, or an error has occurred. If omited, method returns Promise.

                                                                                                                                                                                                                                                                  method commit

                                                                                                                                                                                                                                                                  commit: { (): Promise<void>; (callback: (err?: any) => void): void };

                                                                                                                                                                                                                                                                    method request

                                                                                                                                                                                                                                                                    request: () => Request;

                                                                                                                                                                                                                                                                      method rollback

                                                                                                                                                                                                                                                                      rollback: { (): Promise<void>; (callback: (err?: any) => void): void };

                                                                                                                                                                                                                                                                        class TransactionError

                                                                                                                                                                                                                                                                        class TransactionError extends MSSQLError {}

                                                                                                                                                                                                                                                                          Interfaces

                                                                                                                                                                                                                                                                          interface config

                                                                                                                                                                                                                                                                          interface config {}

                                                                                                                                                                                                                                                                            property arrayRowMode

                                                                                                                                                                                                                                                                            arrayRowMode?: boolean | undefined;

                                                                                                                                                                                                                                                                              property authentication

                                                                                                                                                                                                                                                                              authentication?: tds.ConnectionAuthentication | undefined;

                                                                                                                                                                                                                                                                                property beforeConnect

                                                                                                                                                                                                                                                                                beforeConnect?: ((conn: Connection) => void) | undefined;
                                                                                                                                                                                                                                                                                • Invoked before opening the connection. The parameter conn is the configured tedious Connection. It can be used for attaching event handlers.

                                                                                                                                                                                                                                                                                property connectionTimeout

                                                                                                                                                                                                                                                                                connectionTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                  property database

                                                                                                                                                                                                                                                                                  database?: string | undefined;

                                                                                                                                                                                                                                                                                    property domain

                                                                                                                                                                                                                                                                                    domain?: string | undefined;

                                                                                                                                                                                                                                                                                      property driver

                                                                                                                                                                                                                                                                                      driver?: string | undefined;

                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                        options?: IOptions | undefined;

                                                                                                                                                                                                                                                                                          property parseJSON

                                                                                                                                                                                                                                                                                          parseJSON?: boolean | undefined;

                                                                                                                                                                                                                                                                                            property password

                                                                                                                                                                                                                                                                                            password?: string | undefined;

                                                                                                                                                                                                                                                                                              property pool

                                                                                                                                                                                                                                                                                              pool?: PoolOpts<Connection> | undefined;

                                                                                                                                                                                                                                                                                                property port

                                                                                                                                                                                                                                                                                                port?: number | undefined;

                                                                                                                                                                                                                                                                                                  property requestTimeout

                                                                                                                                                                                                                                                                                                  requestTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                    property server

                                                                                                                                                                                                                                                                                                    server: string;

                                                                                                                                                                                                                                                                                                      property stream

                                                                                                                                                                                                                                                                                                      stream?: boolean | undefined;

                                                                                                                                                                                                                                                                                                        property user

                                                                                                                                                                                                                                                                                                        user?: string | undefined;

                                                                                                                                                                                                                                                                                                          interface IBulkOptions

                                                                                                                                                                                                                                                                                                          interface IBulkOptions {}
                                                                                                                                                                                                                                                                                                          • Options object to be passed through to driver (currently tedious only)

                                                                                                                                                                                                                                                                                                          property checkConstraints

                                                                                                                                                                                                                                                                                                          checkConstraints?: boolean | undefined;
                                                                                                                                                                                                                                                                                                          • Honors constraints during bulk load, using T-SQL CHECK_CONSTRAINTS. (default: false)

                                                                                                                                                                                                                                                                                                          property fireTriggers

                                                                                                                                                                                                                                                                                                          fireTriggers?: boolean | undefined;
                                                                                                                                                                                                                                                                                                          • Honors insert triggers during bulk load, using the T-SQL FIRE_TRIGGERS. (default: false)

                                                                                                                                                                                                                                                                                                          property keepNulls

                                                                                                                                                                                                                                                                                                          keepNulls?: boolean | undefined;
                                                                                                                                                                                                                                                                                                          • Honors null value passed, ignores the default values set on table, using T-SQL KEEP_NULLS. (default: false)

                                                                                                                                                                                                                                                                                                          property tableLock

                                                                                                                                                                                                                                                                                                          tableLock?: boolean | undefined;
                                                                                                                                                                                                                                                                                                          • Places a bulk update(BU) lock on table while performing bulk load, using T-SQL TABLOCK. (default: false)

                                                                                                                                                                                                                                                                                                          interface IBulkResult

                                                                                                                                                                                                                                                                                                          interface IBulkResult {}

                                                                                                                                                                                                                                                                                                            property rowsAffected

                                                                                                                                                                                                                                                                                                            rowsAffected: number;

                                                                                                                                                                                                                                                                                                              interface IColumn

                                                                                                                                                                                                                                                                                                              interface IColumn extends ISqlType {}

                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                  property nullable

                                                                                                                                                                                                                                                                                                                  nullable: boolean;

                                                                                                                                                                                                                                                                                                                    property primary

                                                                                                                                                                                                                                                                                                                    primary: boolean;

                                                                                                                                                                                                                                                                                                                      interface IColumnMetadata

                                                                                                                                                                                                                                                                                                                      interface IColumnMetadata {}

                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                        [name: string]: {
                                                                                                                                                                                                                                                                                                                        index: number;
                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                        length: number;
                                                                                                                                                                                                                                                                                                                        type: (() => ISqlType) | ISqlType;
                                                                                                                                                                                                                                                                                                                        udt?: any;
                                                                                                                                                                                                                                                                                                                        scale?: number | undefined;
                                                                                                                                                                                                                                                                                                                        precision?: number | undefined;
                                                                                                                                                                                                                                                                                                                        nullable: boolean;
                                                                                                                                                                                                                                                                                                                        caseSensitive: boolean;
                                                                                                                                                                                                                                                                                                                        identity: boolean;
                                                                                                                                                                                                                                                                                                                        readOnly: boolean;
                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                          interface IColumnOptions

                                                                                                                                                                                                                                                                                                                          interface IColumnOptions {}

                                                                                                                                                                                                                                                                                                                            property identity

                                                                                                                                                                                                                                                                                                                            identity?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                              property length

                                                                                                                                                                                                                                                                                                                              length?: number | undefined;

                                                                                                                                                                                                                                                                                                                                property nullable

                                                                                                                                                                                                                                                                                                                                nullable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                  property primary

                                                                                                                                                                                                                                                                                                                                  primary?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                    property readOnly

                                                                                                                                                                                                                                                                                                                                    readOnly?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                      interface IMap

                                                                                                                                                                                                                                                                                                                                      interface IMap extends Array<{ js: any; sql: any }> {}

                                                                                                                                                                                                                                                                                                                                        method register

                                                                                                                                                                                                                                                                                                                                        register: (jstype: any, sql: any) => void;

                                                                                                                                                                                                                                                                                                                                          interface IOptions

                                                                                                                                                                                                                                                                                                                                          interface IOptions extends Omit<tds.ConnectionOptions, 'useColumnNames'> {}

                                                                                                                                                                                                                                                                                                                                            property beforeConnect

                                                                                                                                                                                                                                                                                                                                            beforeConnect?: void | undefined;

                                                                                                                                                                                                                                                                                                                                              property connectionString

                                                                                                                                                                                                                                                                                                                                              connectionString?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                property trustedConnection

                                                                                                                                                                                                                                                                                                                                                trustedConnection?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                  interface IProcedureResult

                                                                                                                                                                                                                                                                                                                                                  interface IProcedureResult<T> extends IResult<T> {}

                                                                                                                                                                                                                                                                                                                                                    property returnValue

                                                                                                                                                                                                                                                                                                                                                    returnValue: any;

                                                                                                                                                                                                                                                                                                                                                      interface IRecordSet

                                                                                                                                                                                                                                                                                                                                                      interface IRecordSet<T> extends Array<T> {}

                                                                                                                                                                                                                                                                                                                                                        property columns

                                                                                                                                                                                                                                                                                                                                                        columns: IColumnMetadata;

                                                                                                                                                                                                                                                                                                                                                          method toTable

                                                                                                                                                                                                                                                                                                                                                          toTable: (name?: string) => Table;

                                                                                                                                                                                                                                                                                                                                                            interface IRequestParameters

                                                                                                                                                                                                                                                                                                                                                            interface IRequestParameters {}

                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                              [name: string]: {
                                                                                                                                                                                                                                                                                                                                                              name: string;
                                                                                                                                                                                                                                                                                                                                                              type: (() => ISqlType) | ISqlType;
                                                                                                                                                                                                                                                                                                                                                              io: number;
                                                                                                                                                                                                                                                                                                                                                              value: any;
                                                                                                                                                                                                                                                                                                                                                              length: number;
                                                                                                                                                                                                                                                                                                                                                              scale: number;
                                                                                                                                                                                                                                                                                                                                                              precision: number;
                                                                                                                                                                                                                                                                                                                                                              tvpType: any;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                interface IResult

                                                                                                                                                                                                                                                                                                                                                                interface IResult<T> {}

                                                                                                                                                                                                                                                                                                                                                                  property output

                                                                                                                                                                                                                                                                                                                                                                  output: { [key: string]: any };

                                                                                                                                                                                                                                                                                                                                                                    property recordset

                                                                                                                                                                                                                                                                                                                                                                    recordset: IRecordSet<T extends Array<any> ? T[0] : T>;

                                                                                                                                                                                                                                                                                                                                                                      property recordsets

                                                                                                                                                                                                                                                                                                                                                                      recordsets: T extends Array<any>
                                                                                                                                                                                                                                                                                                                                                                      ? { [P in keyof T]: IRecordSet<T[P]> }
                                                                                                                                                                                                                                                                                                                                                                      : IRecordSet<T>[];

                                                                                                                                                                                                                                                                                                                                                                        property rowsAffected

                                                                                                                                                                                                                                                                                                                                                                        rowsAffected: number[];

                                                                                                                                                                                                                                                                                                                                                                          interface ISqlType

                                                                                                                                                                                                                                                                                                                                                                          interface ISqlType {}

                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                            type: ISqlTypeFactory;

                                                                                                                                                                                                                                                                                                                                                                              interface ISqlTypeFactory

                                                                                                                                                                                                                                                                                                                                                                              interface ISqlTypeFactory {}

                                                                                                                                                                                                                                                                                                                                                                                interface ISqlTypeFactoryWithLength

                                                                                                                                                                                                                                                                                                                                                                                interface ISqlTypeFactoryWithLength extends ISqlTypeFactory {}

                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                  (length?: number): ISqlTypeWithLength;

                                                                                                                                                                                                                                                                                                                                                                                    interface ISqlTypeFactoryWithNoParams

                                                                                                                                                                                                                                                                                                                                                                                    interface ISqlTypeFactoryWithNoParams extends ISqlTypeFactory {}

                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                      (): ISqlTypeWithNoParams;

                                                                                                                                                                                                                                                                                                                                                                                        interface ISqlTypeFactoryWithPrecisionScale

                                                                                                                                                                                                                                                                                                                                                                                        interface ISqlTypeFactoryWithPrecisionScale extends ISqlTypeFactory {}

                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                          (precision?: number, scale?: number): ISqlTypeWithPrecisionScale;

                                                                                                                                                                                                                                                                                                                                                                                            interface ISqlTypeFactoryWithScale

                                                                                                                                                                                                                                                                                                                                                                                            interface ISqlTypeFactoryWithScale extends ISqlTypeFactory {}

                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                              (scale?: number): ISqlTypeWithScale;

                                                                                                                                                                                                                                                                                                                                                                                                interface ISqlTypeFactoryWithTvpType

                                                                                                                                                                                                                                                                                                                                                                                                interface ISqlTypeFactoryWithTvpType extends ISqlTypeFactory {}

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (tvpType?: any): ISqlTypeWithTvpType;

                                                                                                                                                                                                                                                                                                                                                                                                    interface ISqlTypeWithLength

                                                                                                                                                                                                                                                                                                                                                                                                    interface ISqlTypeWithLength extends ISqlType {}

                                                                                                                                                                                                                                                                                                                                                                                                      property length

                                                                                                                                                                                                                                                                                                                                                                                                      length: number;

                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                        type: ISqlTypeFactoryWithLength;

                                                                                                                                                                                                                                                                                                                                                                                                          interface ISqlTypeWithNoParams

                                                                                                                                                                                                                                                                                                                                                                                                          interface ISqlTypeWithNoParams extends ISqlType {}

                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                            type: ISqlTypeFactoryWithNoParams;

                                                                                                                                                                                                                                                                                                                                                                                                              interface ISqlTypeWithPrecisionScale

                                                                                                                                                                                                                                                                                                                                                                                                              interface ISqlTypeWithPrecisionScale extends ISqlType {}

                                                                                                                                                                                                                                                                                                                                                                                                                property precision

                                                                                                                                                                                                                                                                                                                                                                                                                precision: number;

                                                                                                                                                                                                                                                                                                                                                                                                                  property scale

                                                                                                                                                                                                                                                                                                                                                                                                                  scale: number;

                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                    type: ISqlTypeFactoryWithPrecisionScale;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ISqlTypeWithScale

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ISqlTypeWithScale extends ISqlType {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property scale

                                                                                                                                                                                                                                                                                                                                                                                                                        scale: number;

                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                          type: ISqlTypeFactoryWithScale;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface ISqlTypeWithTvpType

                                                                                                                                                                                                                                                                                                                                                                                                                            interface ISqlTypeWithTvpType extends ISqlType {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property tvpType

                                                                                                                                                                                                                                                                                                                                                                                                                              tvpType: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                type: ISqlTypeFactoryWithTvpType;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PoolOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PoolOpts<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                  extends Omit<PoolOptions<T>, 'create' | 'destroy' | 'min' | 'max'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property create

                                                                                                                                                                                                                                                                                                                                                                                                                                    create?: CallbackOrPromise<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                      destroy?: ((resource: T) => any) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property max

                                                                                                                                                                                                                                                                                                                                                                                                                                        max?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property min

                                                                                                                                                                                                                                                                                                                                                                                                                                          min?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                            type Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                            type Connection = tds.Connection;

                                                                                                                                                                                                                                                                                                                                                                                                                                              type IIsolationLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                              type IIsolationLevel = number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                type IRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                type IRow = (string | number | boolean | Date | Buffer | undefined | null)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  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/@types/mssql.

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