deferrable.d.ts
3.37 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/**
* Can be used to
* make foreign key constraints deferrable and to set the constaints within a
* transaction. This is only supported in PostgreSQL.
*
* The foreign keys can be configured like this. It will create a foreign key
* that will check the constraints immediately when the data was inserted.
*
* ```js
* class MyModel extends Model {}
* MyModel.init({
* foreign_id: {
* type: Sequelize.INTEGER,
* references: {
* model: OtherModel,
* key: 'id',
* deferrable: Sequelize.Deferrable.INITIALLY_IMMEDIATE
* }
* }
* }, { sequelize });
* ```
*
* The constraints can be configured in a transaction like this. It will
* trigger a query once the transaction has been started and set the constraints
* to be checked at the very end of the transaction.
*
* ```js
* sequelize.transaction({
* deferrable: Sequelize.Deferrable.SET_DEFERRED
* });
* ```
*/
/**
*
*/
export interface AbstractDeferrableStatic {
new (): Deferrable;
(): Deferrable;
}
export interface Deferrable {
toString(): string;
toSql(): string;
}
export interface InitiallyDeferredDeferrableStatic extends AbstractDeferrableStatic {
new (): InitiallyDeferredDeferrable;
(): InitiallyDeferredDeferrable;
}
export interface InitiallyDeferredDeferrable extends Deferrable {}
export const INITIALLY_DEFERRED: InitiallyDeferredDeferrableStatic;
export interface InitiallyImmediateDeferrableStatic extends AbstractDeferrableStatic {
new (): InitiallyImmediateDeferrable;
(): InitiallyImmediateDeferrable;
}
export interface InitiallyImmediateDeferrable extends Deferrable {}
export const INITIALLY_IMMEDIATE: InitiallyImmediateDeferrableStatic;
export interface NotDeferrableStatic extends AbstractDeferrableStatic {
new (): NotDeferrable;
(): NotDeferrable;
}
export interface NotDeferrable extends Deferrable {}
/**
* Will set the constraints to not deferred. This is the default in PostgreSQL and it make
* it impossible to dynamically defer the constraints within a transaction.
*/
export const NOT: NotDeferrableStatic;
export interface SetDeferredDeferrableStatic extends AbstractDeferrableStatic {
/**
* @param constraints An array of constraint names. Will defer all constraints by default.
*/
new (constraints: string[]): SetDeferredDeferrable;
/**
* @param constraints An array of constraint names. Will defer all constraints by default.
*/
(constraints: string[]): SetDeferredDeferrable;
}
export interface SetDeferredDeferrable extends Deferrable {}
/**
* Will trigger an additional query at the beginning of a
* transaction which sets the constraints to deferred.
*/
export const SET_DEFERRED: SetDeferredDeferrableStatic;
export interface SetImmediateDeferrableStatic extends AbstractDeferrableStatic {
/**
* @param constraints An array of constraint names. Will defer all constraints by default.
*/
new (constraints: string[]): SetImmediateDeferrable;
/**
* @param constraints An array of constraint names. Will defer all constraints by default.
*/
(constraints: string[]): SetImmediateDeferrable;
}
export interface SetImmediateDeferrable extends Deferrable {}
/**
* Will trigger an additional query at the beginning of a
* transaction which sets the constraints to immediately.
*
* @param constraints An array of constraint names. Will defer all constraints by default.
*/
export const SET_IMMEDIATE: SetImmediateDeferrableStatic;