flip/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/FlipsideCrypto/DefinitelyTyped.git synced 2026-02-06 10:56:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

mssql: Adjusted return types of several methods (#14620)

Browse Source 
Also added a IRecordSet interface containing column meta data. Added a super type for sql types.
This commit is contained in:
Jørgen Elgaard Larsen 2017-03-11 02:15:47 +01:00 committed by Mohamed Hegazy
parent 397dc0896a
commit 183a7fa046
1 changed files with 115 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

215
mssql/index.d.ts vendored
View File

@ -1,91 +1,96 @@
// Type definitions for mssql 3.3
// Project: https://www.npmjs.com/package/mssql
// Definitions by: COLSA Corporation <http://www.colsa.com/>, Ben Farr <https://github.com/jaminfarr>, Vitor Buzinaro <https://github.com/buzinas>, Matt Richardson <https://github.com/mrrichar/>
// Definitions by: COLSA Corporation <http://www.colsa.com/>, Ben Farr <https://github.com/jaminfarr>, Vitor Buzinaro <https://github.com/buzinas>, Matt Richardson <https://github.com/mrrichar/>, Jørgen Elgaard Larsen <https://github.com/elhaard/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
import events = require('events');
export interface ISqlType {
type: ISqlTypeFactory;
}
export interface ISqlTypeWithNoParams extends ISqlType { type: ISqlTypeFactoryWithNoParams }
export interface ISqlTypeWithLength extends ISqlType { type: ISqlTypeFactoryWithLength; length: number }
export interface ISqlTypeWithScale extends ISqlType { type: ISqlTypeFactoryWithScale; scale: number }
export interface ISqlTypeWithPrecisionScale extends ISqlType { type: ISqlTypeFactoryWithPrecisionScale; precision: number, scale: number }
export interface ISqlTypeWithTvpType extends ISqlType { type: ISqlTypeFactoryWithTvpType; tvpType: any }
type sqlTypeWithNoParams = { type: sqlTypeFactoryWithNoParams }
type sqlTypeWithLength = { type: sqlTypeFactoryWithLength, length: number }
type sqlTypeWithScale = { type: sqlTypeFactoryWithScale, scale: number }
type sqlTypeWithPrecisionScale = { type: sqlTypeFactoryWithPrecisionScale, precision: number, scale: number }
type sqlTypeWithTvpType = { type: sqlTypeFactoryWithTvpType, tvpType: any }
export interface ISqlTypeFactory {
}
export interface ISqlTypeFactoryWithNoParams extends ISqlTypeFactory { (): ISqlTypeWithNoParams; }
export interface ISqlTypeFactoryWithLength extends ISqlTypeFactory { (length?: number): ISqlTypeWithLength }
export interface ISqlTypeFactoryWithScale extends ISqlTypeFactory { (scale?: number): ISqlTypeWithScale }
export interface ISqlTypeFactoryWithPrecisionScale extends ISqlTypeFactory { (precision?: number, scale?: number): ISqlTypeWithPrecisionScale; }
export interface ISqlTypeFactoryWithTvpType extends ISqlTypeFactory { (tvpType: any): ISqlTypeWithTvpType }
type sqlTypeFactoryWithNoParams = () => sqlTypeWithNoParams;
type sqlTypeFactoryWithLength = (length?: number) => sqlTypeWithLength;
type sqlTypeFactoryWithScale = (scale?: number) => sqlTypeWithScale;
type sqlTypeFactoryWithPrecisionScale = (precision?: number, scale?: number) => sqlTypeWithPrecisionScale;
type sqlTypeFactoryWithTvpType = (tvpType: any) => sqlTypeWithTvpType;
export declare var VarChar: sqlTypeFactoryWithLength;
export declare var NVarChar: sqlTypeFactoryWithLength;
export declare var Text: sqlTypeFactoryWithNoParams;
export declare var Int: sqlTypeFactoryWithNoParams;
export declare var BigInt: sqlTypeFactoryWithNoParams;
export declare var TinyInt: sqlTypeFactoryWithNoParams;
export declare var SmallInt: sqlTypeFactoryWithNoParams;
export declare var Bit: sqlTypeFactoryWithNoParams;
export declare var Float: sqlTypeFactoryWithNoParams;
export declare var Numeric: sqlTypeFactoryWithPrecisionScale;
export declare var Decimal: sqlTypeFactoryWithPrecisionScale;
export declare var Real: sqlTypeFactoryWithNoParams;
export declare var Date: sqlTypeFactoryWithNoParams;
export declare var DateTime: sqlTypeFactoryWithNoParams;
export declare var DateTime2: sqlTypeFactoryWithScale;
export declare var DateTimeOffset: sqlTypeFactoryWithScale;
export declare var SmallDateTime: sqlTypeFactoryWithNoParams;
export declare var Time: sqlTypeFactoryWithScale;
export declare var UniqueIdentifier: sqlTypeFactoryWithNoParams;
export declare var SmallMoney: sqlTypeFactoryWithNoParams;
export declare var Money: sqlTypeFactoryWithNoParams;
export declare var Binary: sqlTypeFactoryWithNoParams;
export declare var VarBinary: sqlTypeFactoryWithLength;
export declare var Image: sqlTypeFactoryWithNoParams;
export declare var Xml: sqlTypeFactoryWithNoParams;
export declare var Char: sqlTypeFactoryWithLength;
export declare var NChar: sqlTypeFactoryWithLength;
export declare var NText: sqlTypeFactoryWithNoParams;
export declare var TVP: sqlTypeFactoryWithTvpType;
export declare var UDT: sqlTypeFactoryWithNoParams;
export declare var Geography: sqlTypeFactoryWithNoParams;
export declare var Geometry: sqlTypeFactoryWithNoParams;
export declare var VarChar: ISqlTypeFactoryWithLength;
export declare var NVarChar: ISqlTypeFactoryWithLength;
export declare var Text: ISqlTypeFactoryWithNoParams;
export declare var Int: ISqlTypeFactoryWithNoParams;
export declare var BigInt: ISqlTypeFactoryWithNoParams;
export declare var TinyInt: ISqlTypeFactoryWithNoParams;
export declare var SmallInt: ISqlTypeFactoryWithNoParams;
export declare var Bit: ISqlTypeFactoryWithNoParams;
export declare var Float: ISqlTypeFactoryWithNoParams;
export declare var Numeric: ISqlTypeFactoryWithPrecisionScale;
export declare var Decimal: ISqlTypeFactoryWithPrecisionScale;
export declare var Real: ISqlTypeFactoryWithNoParams;
export declare var Date: ISqlTypeFactoryWithNoParams;
export declare var DateTime: ISqlTypeFactoryWithNoParams;
export declare var DateTime2: ISqlTypeFactoryWithScale;
export declare var DateTimeOffset: ISqlTypeFactoryWithScale;
export declare var SmallDateTime: ISqlTypeFactoryWithNoParams;
export declare var Time: ISqlTypeFactoryWithScale;
export declare var UniqueIdentifier: ISqlTypeFactoryWithNoParams;
export declare var SmallMoney: ISqlTypeFactoryWithNoParams;
export declare var Money: ISqlTypeFactoryWithNoParams;
export declare var Binary: ISqlTypeFactoryWithNoParams;
export declare var VarBinary: ISqlTypeFactoryWithLength;
export declare var Image: ISqlTypeFactoryWithNoParams;
export declare var Xml: ISqlTypeFactoryWithNoParams;
export declare var Char: ISqlTypeFactoryWithLength;
export declare var NChar: ISqlTypeFactoryWithLength;
export declare var NText: ISqlTypeFactoryWithNoParams;
export declare var TVP: ISqlTypeFactoryWithTvpType;
export declare var UDT: ISqlTypeFactoryWithNoParams;
export declare var Geography: ISqlTypeFactoryWithNoParams;
export declare var Geometry: ISqlTypeFactoryWithNoParams;
export declare var TYPES: {
VarChar: sqlTypeFactoryWithLength;
NVarChar: sqlTypeFactoryWithLength;
Text: sqlTypeFactoryWithNoParams;
Int: sqlTypeFactoryWithNoParams;
BigInt: sqlTypeFactoryWithNoParams;
TinyInt: sqlTypeFactoryWithNoParams;
SmallInt: sqlTypeFactoryWithNoParams;
Bit: sqlTypeFactoryWithNoParams;
Float: sqlTypeFactoryWithNoParams;
Numeric: sqlTypeFactoryWithPrecisionScale;
Decimal: sqlTypeFactoryWithPrecisionScale;
Real: sqlTypeFactoryWithNoParams;
Date: sqlTypeFactoryWithNoParams;
DateTime: sqlTypeFactoryWithNoParams;
DateTime2: sqlTypeFactoryWithScale;
DateTimeOffset: sqlTypeFactoryWithScale;
SmallDateTime: sqlTypeFactoryWithNoParams;
Time: sqlTypeFactoryWithScale;
UniqueIdentifier: sqlTypeFactoryWithNoParams;
SmallMoney: sqlTypeFactoryWithNoParams;
Money: sqlTypeFactoryWithNoParams;
Binary: sqlTypeFactoryWithNoParams;
VarBinary: sqlTypeFactoryWithLength;
Image: sqlTypeFactoryWithNoParams;
Xml: sqlTypeFactoryWithNoParams;
Char: sqlTypeFactoryWithLength;
NChar: sqlTypeFactoryWithLength;
NText: sqlTypeFactoryWithNoParams;
TVP: sqlTypeFactoryWithTvpType;
UDT: sqlTypeFactoryWithNoParams;
Geography: sqlTypeFactoryWithNoParams;
Geometry: sqlTypeFactoryWithNoParams;
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;
};
export declare var MAX: number;
@ -100,8 +105,19 @@ interface IMap extends Array<{ js: any, sql: any }> {
export declare var map: IMap;
export declare var DRIVERS: string[];
export interface IColumnMetadata {
[name: string]: {
index: number;
name: string;
length: number;
type: ISqlType;
udt?: any;
}
}
export interface IRecordSet<T> extends Array<T> {
columns: IColumnMetadata;
}
type recordSet = any;
type IIsolationLevel = number;
export declare var ISOLATION_LEVEL: {
@ -204,22 +220,23 @@ export declare class Request extends events.EventEmitter {
public constructor(connection?: Connection);
public constructor(transaction: Transaction);
public constructor(preparedStatement: PreparedStatement);
public execute(procedure: string): Promise<recordSet>;
public execute<Entity>(procedure: string, callback: (err?: any, recordsets?: Entity[], returnValue?: any, rowsAffected?: number) => void): void;
public input(name: string, value: any): void;
public input(name: string, type: any, value: any): void;
public output(name: string, type: any, value?: any): void;
public pipe(stream: NodeJS.WritableStream): void;
public query(command: string): Promise<void>;
public query<Entity>(command: string): Promise<Entity[]>;
public query(command: string, callback: (err?: any, recordset?: any, rowsAffected?: number) => void): void;
public query<Entity>(command: string, callback: (err?: any, recordset?: Entity[]) => void): void;
public batch(batch: string): Promise<recordSet>;
public batch<Entity>(batch: string): Promise<Entity[]>;
public batch(batch: string, callback: (err?: any, recordset?: any) => void): void;
public batch<Entity>(batch: string, callback: (err?: any, recordset?: Entity[]) => void): void;
public bulk(table: Table): Promise<void>;
public bulk(table: Table, callback: (err: any, rowCount: any) => void): void;
public execute(procedure: string): Promise<IRecordSet<any>>;
public execute<Entity>(procedure: string): Promise<IRecordSet<Entity>>;
public execute<Entity>(procedure: string, callback: (err?: any, recordsets?: IRecordSet<Entity>, returnValue?: any, rowsAffected?: number) => void): void;
public input(name: string, value: any): Request;
public input(name: string, type: any, value: any): Request;
public output(name: string, type: any, value?: any): Request;
public pipe(stream: NodeJS.WritableStream): NodeJS.WritableStream;
public query(command: string): Promise<IRecordSet<any>>;
public query<Entity>(command: string): Promise<IRecordSet<Entity>>;
public query<Entity>(command: string, callback: (err?: Error, recordset?: IRecordSet<Entity>, rowsAffected?: number) => void): void;
public query<Entity>(command: string, callback: (err?: Error, recordset?: IRecordSet<Entity>) => void): void;
public batch(batch: string): Promise<IRecordSet<any>>;
public batch<Entity>(batch: string): Promise<IRecordSet<Entity>>;
public batch(batch: string, callback: (err?: Error, recordset?: IRecordSet<any>) => void): void;
public batch<Entity>(batch: string, callback: (err?: any, recordset?: IRecordSet<Entity>) => void): void;
public bulk(table: Table): Promise<number>;
public bulk(table: Table, callback: (err: Error, rowCount: any) => void): void;
public cancel(): void;
}
@ -258,16 +275,14 @@ export declare class PreparedStatement extends events.EventEmitter {
public multiple: boolean;
public stream: any;
public constructor(connection?: Connection);
public input(name: string, type: any): void;
public output(name: string, type: any): void;
public input(name: string, type: ISqlType): PreparedStatement;
public output(name: string, type: ISqlType): PreparedStatement;
public prepare(statement?: string): Promise<void>;
public prepare(statement?: string, callback?: (err?: any) => void): void;
public execute(values: Object): Promise<recordSet>;
public execute<Entity>(values: Object): Promise<Entity[]>;
public execute(values: Object, callback: (err: any, recordSet: recordSet, rowsAffected: number) => void): void;
public execute<Entity>(values: Object, callback: (err: any, recordSet: Entity[]) => void): void;
public prepare(statement?: string, callback?: (err?: Error) => void): PreparedStatement;
public execute(values: Object): Promise<void>;
public execute(values: Object, callback: (err?: Error) => void): Request;
public unprepare(): Promise<void>;
public unprepare(callback: (err?: any) => void): void;
public unprepare(callback: (err?: Error) => void): PreparedStatement;
}
export declare class PreparedStatementError implements Error {