@types/mssql

  • Version 8.0.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;

                                                                                                                            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;

                                                                                                                                                                                                                    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 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 tds.ConnectionOptions {}

                                                                                                                                                                                                                                                                                                                                        property beforeConnect

                                                                                                                                                                                                                                                                                                                                        beforeConnect?: void | undefined;

                                                                                                                                                                                                                                                                                                                                          property connectionString

                                                                                                                                                                                                                                                                                                                                          connectionString?: string | undefined;

                                                                                                                                                                                                                                                                                                                                            property enableArithAbort

                                                                                                                                                                                                                                                                                                                                            enableArithAbort?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                              property instanceName

                                                                                                                                                                                                                                                                                                                                              instanceName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                property trustedConnection

                                                                                                                                                                                                                                                                                                                                                trustedConnection?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                  property useUTC

                                                                                                                                                                                                                                                                                                                                                  useUTC?: 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>;

                                                                                                                                                                                                                                                                                                                                                                        property recordsets

                                                                                                                                                                                                                                                                                                                                                                        recordsets: 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>