drizzle-kit 0.28.0 → 0.28.1-08d2486
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -7
- package/api.js +1015 -714
- package/api.mjs +1015 -714
- package/bin.cjs +680 -85
- package/package.json +1 -1
package/api.js
CHANGED
@@ -21121,7 +21121,7 @@ var version;
|
|
21121
21121
|
var init_version = __esm({
|
21122
21122
|
"../drizzle-orm/dist/version.js"() {
|
21123
21123
|
"use strict";
|
21124
|
-
version = "0.36.
|
21124
|
+
version = "0.36.4";
|
21125
21125
|
}
|
21126
21126
|
});
|
21127
21127
|
|
@@ -21407,7 +21407,11 @@ var init_sql = __esm({
|
|
21407
21407
|
if (_config.invokeSource === "indexes") {
|
21408
21408
|
return { sql: escapeName(columnName), params: [] };
|
21409
21409
|
}
|
21410
|
-
|
21410
|
+
const schemaName = chunk.table[Table2.Symbol.Schema];
|
21411
|
+
return {
|
21412
|
+
sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table2.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table2.Symbol.Name]) + "." + escapeName(columnName),
|
21413
|
+
params: []
|
21414
|
+
};
|
21411
21415
|
}
|
21412
21416
|
if (is(chunk, View3)) {
|
21413
21417
|
const schemaName = chunk[ViewBaseConfig].schema;
|
@@ -22140,7 +22144,7 @@ function haveSameKeys(left, right) {
|
|
22140
22144
|
}
|
22141
22145
|
function mapUpdateSet(table4, values) {
|
22142
22146
|
const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {
|
22143
|
-
if (is(value, SQL)) {
|
22147
|
+
if (is(value, SQL) || is(value, Column2)) {
|
22144
22148
|
return [key, value];
|
22145
22149
|
} else {
|
22146
22150
|
return [key, new Param(value, table4[Table2.Symbol.Columns][key])];
|
@@ -24579,9 +24583,10 @@ var init_delete = __esm({
|
|
24579
24583
|
constructor(table4, session, dialect4, withList) {
|
24580
24584
|
super();
|
24581
24585
|
__publicField(this, "config");
|
24586
|
+
__publicField(this, "authToken");
|
24582
24587
|
__publicField(this, "execute", (placeholderValues) => {
|
24583
24588
|
return tracer.startActiveSpan("drizzle.operation", () => {
|
24584
|
-
return this._prepare().execute(placeholderValues);
|
24589
|
+
return this._prepare().execute(placeholderValues, this.authToken);
|
24585
24590
|
});
|
24586
24591
|
});
|
24587
24592
|
this.session = session;
|
@@ -24642,167 +24647,16 @@ var init_delete = __esm({
|
|
24642
24647
|
prepare(name2) {
|
24643
24648
|
return this._prepare(name2);
|
24644
24649
|
}
|
24645
|
-
$dynamic() {
|
24646
|
-
return this;
|
24647
|
-
}
|
24648
|
-
};
|
24649
|
-
__publicField(PgDeleteBase, _a124, "PgDelete");
|
24650
|
-
}
|
24651
|
-
});
|
24652
|
-
|
24653
|
-
// ../drizzle-orm/dist/pg-core/query-builders/insert.js
|
24654
|
-
var _a125, PgInsertBuilder, _a126, _b98, PgInsertBase;
|
24655
|
-
var init_insert = __esm({
|
24656
|
-
"../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
|
24657
|
-
"use strict";
|
24658
|
-
init_entity();
|
24659
|
-
init_query_promise();
|
24660
|
-
init_sql();
|
24661
|
-
init_table();
|
24662
|
-
init_tracing();
|
24663
|
-
init_utils2();
|
24664
|
-
_a125 = entityKind;
|
24665
|
-
PgInsertBuilder = class {
|
24666
|
-
constructor(table4, session, dialect4, withList) {
|
24667
|
-
this.table = table4;
|
24668
|
-
this.session = session;
|
24669
|
-
this.dialect = dialect4;
|
24670
|
-
this.withList = withList;
|
24671
|
-
}
|
24672
|
-
values(values) {
|
24673
|
-
values = Array.isArray(values) ? values : [values];
|
24674
|
-
if (values.length === 0) {
|
24675
|
-
throw new Error("values() must be called with at least one value");
|
24676
|
-
}
|
24677
|
-
const mappedValues = values.map((entry) => {
|
24678
|
-
const result = {};
|
24679
|
-
const cols = this.table[Table2.Symbol.Columns];
|
24680
|
-
for (const colKey of Object.keys(entry)) {
|
24681
|
-
const colValue = entry[colKey];
|
24682
|
-
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
24683
|
-
}
|
24684
|
-
return result;
|
24685
|
-
});
|
24686
|
-
return new PgInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
|
24687
|
-
}
|
24688
|
-
};
|
24689
|
-
__publicField(PgInsertBuilder, _a125, "PgInsertBuilder");
|
24690
|
-
PgInsertBase = class extends (_b98 = QueryPromise, _a126 = entityKind, _b98) {
|
24691
|
-
constructor(table4, values, session, dialect4, withList) {
|
24692
|
-
super();
|
24693
|
-
__publicField(this, "config");
|
24694
|
-
__publicField(this, "execute", (placeholderValues) => {
|
24695
|
-
return tracer.startActiveSpan("drizzle.operation", () => {
|
24696
|
-
return this._prepare().execute(placeholderValues);
|
24697
|
-
});
|
24698
|
-
});
|
24699
|
-
this.session = session;
|
24700
|
-
this.dialect = dialect4;
|
24701
|
-
this.config = { table: table4, values, withList };
|
24702
|
-
}
|
24703
|
-
returning(fields = this.config.table[Table2.Symbol.Columns]) {
|
24704
|
-
this.config.returning = orderSelectedFields(fields);
|
24705
|
-
return this;
|
24706
|
-
}
|
24707
|
-
/**
|
24708
|
-
* Adds an `on conflict do nothing` clause to the query.
|
24709
|
-
*
|
24710
|
-
* Calling this method simply avoids inserting a row as its alternative action.
|
24711
|
-
*
|
24712
|
-
* See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
|
24713
|
-
*
|
24714
|
-
* @param config The `target` and `where` clauses.
|
24715
|
-
*
|
24716
|
-
* @example
|
24717
|
-
* ```ts
|
24718
|
-
* // Insert one row and cancel the insert if there's a conflict
|
24719
|
-
* await db.insert(cars)
|
24720
|
-
* .values({ id: 1, brand: 'BMW' })
|
24721
|
-
* .onConflictDoNothing();
|
24722
|
-
*
|
24723
|
-
* // Explicitly specify conflict target
|
24724
|
-
* await db.insert(cars)
|
24725
|
-
* .values({ id: 1, brand: 'BMW' })
|
24726
|
-
* .onConflictDoNothing({ target: cars.id });
|
24727
|
-
* ```
|
24728
|
-
*/
|
24729
|
-
onConflictDoNothing(config = {}) {
|
24730
|
-
if (config.target === void 0) {
|
24731
|
-
this.config.onConflict = sql`do nothing`;
|
24732
|
-
} else {
|
24733
|
-
let targetColumn = "";
|
24734
|
-
targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
|
24735
|
-
const whereSql = config.where ? sql` where ${config.where}` : void 0;
|
24736
|
-
this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
|
24737
|
-
}
|
24738
|
-
return this;
|
24739
|
-
}
|
24740
|
-
/**
|
24741
|
-
* Adds an `on conflict do update` clause to the query.
|
24742
|
-
*
|
24743
|
-
* Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
|
24744
|
-
*
|
24745
|
-
* See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
|
24746
|
-
*
|
24747
|
-
* @param config The `target`, `set` and `where` clauses.
|
24748
|
-
*
|
24749
|
-
* @example
|
24750
|
-
* ```ts
|
24751
|
-
* // Update the row if there's a conflict
|
24752
|
-
* await db.insert(cars)
|
24753
|
-
* .values({ id: 1, brand: 'BMW' })
|
24754
|
-
* .onConflictDoUpdate({
|
24755
|
-
* target: cars.id,
|
24756
|
-
* set: { brand: 'Porsche' }
|
24757
|
-
* });
|
24758
|
-
*
|
24759
|
-
* // Upsert with 'where' clause
|
24760
|
-
* await db.insert(cars)
|
24761
|
-
* .values({ id: 1, brand: 'BMW' })
|
24762
|
-
* .onConflictDoUpdate({
|
24763
|
-
* target: cars.id,
|
24764
|
-
* set: { brand: 'newBMW' },
|
24765
|
-
* targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
|
24766
|
-
* });
|
24767
|
-
* ```
|
24768
|
-
*/
|
24769
|
-
onConflictDoUpdate(config) {
|
24770
|
-
if (config.where && (config.targetWhere || config.setWhere)) {
|
24771
|
-
throw new Error(
|
24772
|
-
'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
|
24773
|
-
);
|
24774
|
-
}
|
24775
|
-
const whereSql = config.where ? sql` where ${config.where}` : void 0;
|
24776
|
-
const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
|
24777
|
-
const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
|
24778
|
-
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
24779
|
-
let targetColumn = "";
|
24780
|
-
targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
|
24781
|
-
this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
|
24782
|
-
return this;
|
24783
|
-
}
|
24784
|
-
/** @internal */
|
24785
|
-
getSQL() {
|
24786
|
-
return this.dialect.buildInsertQuery(this.config);
|
24787
|
-
}
|
24788
|
-
toSQL() {
|
24789
|
-
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
24790
|
-
return rest;
|
24791
|
-
}
|
24792
24650
|
/** @internal */
|
24793
|
-
|
24794
|
-
|
24795
|
-
|
24796
|
-
});
|
24797
|
-
}
|
24798
|
-
prepare(name2) {
|
24799
|
-
return this._prepare(name2);
|
24651
|
+
setToken(token) {
|
24652
|
+
this.authToken = token;
|
24653
|
+
return this;
|
24800
24654
|
}
|
24801
24655
|
$dynamic() {
|
24802
24656
|
return this;
|
24803
24657
|
}
|
24804
24658
|
};
|
24805
|
-
__publicField(
|
24659
|
+
__publicField(PgDeleteBase, _a124, "PgDelete");
|
24806
24660
|
}
|
24807
24661
|
});
|
24808
24662
|
|
@@ -24821,13 +24675,13 @@ function toCamelCase(input) {
|
|
24821
24675
|
function noopCase(input) {
|
24822
24676
|
return input;
|
24823
24677
|
}
|
24824
|
-
var
|
24678
|
+
var _a125, CasingCache;
|
24825
24679
|
var init_casing = __esm({
|
24826
24680
|
"../drizzle-orm/dist/casing.js"() {
|
24827
24681
|
"use strict";
|
24828
24682
|
init_entity();
|
24829
24683
|
init_table();
|
24830
|
-
|
24684
|
+
_a125 = entityKind;
|
24831
24685
|
CasingCache = class {
|
24832
24686
|
constructor(casing2) {
|
24833
24687
|
/** @internal */
|
@@ -24864,25 +24718,25 @@ var init_casing = __esm({
|
|
24864
24718
|
this.cachedTables = {};
|
24865
24719
|
}
|
24866
24720
|
};
|
24867
|
-
__publicField(CasingCache,
|
24721
|
+
__publicField(CasingCache, _a125, "CasingCache");
|
24868
24722
|
}
|
24869
24723
|
});
|
24870
24724
|
|
24871
24725
|
// ../drizzle-orm/dist/pg-core/view-base.js
|
24872
|
-
var
|
24726
|
+
var _a126, _b98, PgViewBase;
|
24873
24727
|
var init_view_base = __esm({
|
24874
24728
|
"../drizzle-orm/dist/pg-core/view-base.js"() {
|
24875
24729
|
"use strict";
|
24876
24730
|
init_entity();
|
24877
24731
|
init_sql();
|
24878
|
-
PgViewBase = class extends (
|
24732
|
+
PgViewBase = class extends (_b98 = View3, _a126 = entityKind, _b98) {
|
24879
24733
|
};
|
24880
|
-
__publicField(PgViewBase,
|
24734
|
+
__publicField(PgViewBase, _a126, "PgViewBase");
|
24881
24735
|
}
|
24882
24736
|
});
|
24883
24737
|
|
24884
24738
|
// ../drizzle-orm/dist/pg-core/dialect.js
|
24885
|
-
var
|
24739
|
+
var _a127, PgDialect;
|
24886
24740
|
var init_dialect = __esm({
|
24887
24741
|
"../drizzle-orm/dist/pg-core/dialect.js"() {
|
24888
24742
|
"use strict";
|
@@ -24901,7 +24755,7 @@ var init_dialect = __esm({
|
|
24901
24755
|
init_utils2();
|
24902
24756
|
init_view_common();
|
24903
24757
|
init_view_base();
|
24904
|
-
|
24758
|
+
_a127 = entityKind;
|
24905
24759
|
PgDialect = class {
|
24906
24760
|
constructor(config) {
|
24907
24761
|
/** @internal */
|
@@ -24981,12 +24835,19 @@ var init_dialect = __esm({
|
|
24981
24835
|
return [res];
|
24982
24836
|
}));
|
24983
24837
|
}
|
24984
|
-
buildUpdateQuery({ table: table4, set, where, returning, withList }) {
|
24838
|
+
buildUpdateQuery({ table: table4, set, where, returning, withList, from, joins }) {
|
24985
24839
|
const withSql = this.buildWithCTE(withList);
|
24840
|
+
const tableName = table4[PgTable.Symbol.Name];
|
24841
|
+
const tableSchema = table4[PgTable.Symbol.Schema];
|
24842
|
+
const origTableName = table4[PgTable.Symbol.OriginalName];
|
24843
|
+
const alias = tableName === origTableName ? void 0 : tableName;
|
24844
|
+
const tableSql = sql`${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}`;
|
24986
24845
|
const setSql = this.buildUpdateSet(table4, set);
|
24987
|
-
const
|
24846
|
+
const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
|
24847
|
+
const joinsSql = this.buildJoins(joins);
|
24848
|
+
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}` : void 0;
|
24988
24849
|
const whereSql = where ? sql` where ${where}` : void 0;
|
24989
|
-
return sql`${withSql}update ${
|
24850
|
+
return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`;
|
24990
24851
|
}
|
24991
24852
|
/**
|
24992
24853
|
* Builds selection SQL with provided fields/expressions
|
@@ -25038,6 +24899,54 @@ var init_dialect = __esm({
|
|
25038
24899
|
});
|
25039
24900
|
return sql.join(chunks);
|
25040
24901
|
}
|
24902
|
+
buildJoins(joins) {
|
24903
|
+
if (!joins || joins.length === 0) {
|
24904
|
+
return void 0;
|
24905
|
+
}
|
24906
|
+
const joinsArray = [];
|
24907
|
+
for (const [index4, joinMeta] of joins.entries()) {
|
24908
|
+
if (index4 === 0) {
|
24909
|
+
joinsArray.push(sql` `);
|
24910
|
+
}
|
24911
|
+
const table4 = joinMeta.table;
|
24912
|
+
const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
|
24913
|
+
if (is(table4, PgTable)) {
|
24914
|
+
const tableName = table4[PgTable.Symbol.Name];
|
24915
|
+
const tableSchema = table4[PgTable.Symbol.Schema];
|
24916
|
+
const origTableName = table4[PgTable.Symbol.OriginalName];
|
24917
|
+
const alias = tableName === origTableName ? void 0 : joinMeta.alias;
|
24918
|
+
joinsArray.push(
|
24919
|
+
sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
|
24920
|
+
);
|
24921
|
+
} else if (is(table4, View3)) {
|
24922
|
+
const viewName = table4[ViewBaseConfig].name;
|
24923
|
+
const viewSchema = table4[ViewBaseConfig].schema;
|
24924
|
+
const origViewName = table4[ViewBaseConfig].originalName;
|
24925
|
+
const alias = viewName === origViewName ? void 0 : joinMeta.alias;
|
24926
|
+
joinsArray.push(
|
24927
|
+
sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
|
24928
|
+
);
|
24929
|
+
} else {
|
24930
|
+
joinsArray.push(
|
24931
|
+
sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table4} on ${joinMeta.on}`
|
24932
|
+
);
|
24933
|
+
}
|
24934
|
+
if (index4 < joins.length - 1) {
|
24935
|
+
joinsArray.push(sql` `);
|
24936
|
+
}
|
24937
|
+
}
|
24938
|
+
return sql.join(joinsArray);
|
24939
|
+
}
|
24940
|
+
buildFromTable(table4) {
|
24941
|
+
if (is(table4, Table2) && table4[Table2.Symbol.OriginalName] !== table4[Table2.Symbol.Name]) {
|
24942
|
+
let fullName = sql`${sql.identifier(table4[Table2.Symbol.OriginalName])}`;
|
24943
|
+
if (table4[Table2.Symbol.Schema]) {
|
24944
|
+
fullName = sql`${sql.identifier(table4[Table2.Symbol.Schema])}.${fullName}`;
|
24945
|
+
}
|
24946
|
+
return sql`${fullName} ${sql.identifier(table4[Table2.Symbol.Name])}`;
|
24947
|
+
}
|
24948
|
+
return table4;
|
24949
|
+
}
|
25041
24950
|
buildSelectQuery({
|
25042
24951
|
withList,
|
25043
24952
|
fields,
|
@@ -25072,51 +24981,8 @@ var init_dialect = __esm({
|
|
25072
24981
|
distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
|
25073
24982
|
}
|
25074
24983
|
const selection = this.buildSelection(fieldsList, { isSingleTable });
|
25075
|
-
const tableSql = (
|
25076
|
-
|
25077
|
-
let fullName = sql`${sql.identifier(table4[Table2.Symbol.OriginalName])}`;
|
25078
|
-
if (table4[Table2.Symbol.Schema]) {
|
25079
|
-
fullName = sql`${sql.identifier(table4[Table2.Symbol.Schema])}.${fullName}`;
|
25080
|
-
}
|
25081
|
-
return sql`${fullName} ${sql.identifier(table4[Table2.Symbol.Name])}`;
|
25082
|
-
}
|
25083
|
-
return table4;
|
25084
|
-
})();
|
25085
|
-
const joinsArray = [];
|
25086
|
-
if (joins) {
|
25087
|
-
for (const [index4, joinMeta] of joins.entries()) {
|
25088
|
-
if (index4 === 0) {
|
25089
|
-
joinsArray.push(sql` `);
|
25090
|
-
}
|
25091
|
-
const table22 = joinMeta.table;
|
25092
|
-
const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
|
25093
|
-
if (is(table22, PgTable)) {
|
25094
|
-
const tableName = table22[PgTable.Symbol.Name];
|
25095
|
-
const tableSchema = table22[PgTable.Symbol.Schema];
|
25096
|
-
const origTableName = table22[PgTable.Symbol.OriginalName];
|
25097
|
-
const alias = tableName === origTableName ? void 0 : joinMeta.alias;
|
25098
|
-
joinsArray.push(
|
25099
|
-
sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
|
25100
|
-
);
|
25101
|
-
} else if (is(table22, View3)) {
|
25102
|
-
const viewName = table22[ViewBaseConfig].name;
|
25103
|
-
const viewSchema = table22[ViewBaseConfig].schema;
|
25104
|
-
const origViewName = table22[ViewBaseConfig].originalName;
|
25105
|
-
const alias = viewName === origViewName ? void 0 : joinMeta.alias;
|
25106
|
-
joinsArray.push(
|
25107
|
-
sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
|
25108
|
-
);
|
25109
|
-
} else {
|
25110
|
-
joinsArray.push(
|
25111
|
-
sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table22} on ${joinMeta.on}`
|
25112
|
-
);
|
25113
|
-
}
|
25114
|
-
if (index4 < joins.length - 1) {
|
25115
|
-
joinsArray.push(sql` `);
|
25116
|
-
}
|
25117
|
-
}
|
25118
|
-
}
|
25119
|
-
const joinsSql = sql.join(joinsArray);
|
24984
|
+
const tableSql = this.buildFromTable(table4);
|
24985
|
+
const joinsSql = this.buildJoins(joins);
|
25120
24986
|
const whereSql = where ? sql` where ${where}` : void 0;
|
25121
24987
|
const havingSql = having ? sql` having ${having}` : void 0;
|
25122
24988
|
let orderBySql;
|
@@ -25197,43 +25063,55 @@ var init_dialect = __esm({
|
|
25197
25063
|
const offsetSql = offset ? sql` offset ${offset}` : void 0;
|
25198
25064
|
return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
|
25199
25065
|
}
|
25200
|
-
buildInsertQuery({ table: table4, values, onConflict, returning, withList }) {
|
25066
|
+
buildInsertQuery({ table: table4, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_ }) {
|
25201
25067
|
const valuesSqlList = [];
|
25202
25068
|
const columns = table4[Table2.Symbol.Columns];
|
25203
25069
|
const colEntries = Object.entries(columns).filter(([_2, col]) => !col.shouldDisableInsert());
|
25204
25070
|
const insertOrder = colEntries.map(
|
25205
25071
|
([, column4]) => sql.identifier(this.casing.getColumnCasing(column4))
|
25206
25072
|
);
|
25207
|
-
|
25208
|
-
const
|
25209
|
-
|
25210
|
-
|
25211
|
-
|
25212
|
-
|
25213
|
-
|
25214
|
-
|
25215
|
-
|
25216
|
-
|
25217
|
-
|
25218
|
-
|
25219
|
-
|
25073
|
+
if (select) {
|
25074
|
+
const select2 = valuesOrSelect;
|
25075
|
+
if (is(select2, SQL)) {
|
25076
|
+
valuesSqlList.push(select2);
|
25077
|
+
} else {
|
25078
|
+
valuesSqlList.push(select2.getSQL());
|
25079
|
+
}
|
25080
|
+
} else {
|
25081
|
+
const values = valuesOrSelect;
|
25082
|
+
valuesSqlList.push(sql.raw("values "));
|
25083
|
+
for (const [valueIndex, value] of values.entries()) {
|
25084
|
+
const valueList = [];
|
25085
|
+
for (const [fieldName, col] of colEntries) {
|
25086
|
+
const colValue = value[fieldName];
|
25087
|
+
if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
|
25088
|
+
if (col.defaultFn !== void 0) {
|
25089
|
+
const defaultFnResult = col.defaultFn();
|
25090
|
+
const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
|
25091
|
+
valueList.push(defaultValue);
|
25092
|
+
} else if (!col.default && col.onUpdateFn !== void 0) {
|
25093
|
+
const onUpdateFnResult = col.onUpdateFn();
|
25094
|
+
const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
|
25095
|
+
valueList.push(newValue);
|
25096
|
+
} else {
|
25097
|
+
valueList.push(sql`default`);
|
25098
|
+
}
|
25220
25099
|
} else {
|
25221
|
-
valueList.push(
|
25100
|
+
valueList.push(colValue);
|
25222
25101
|
}
|
25223
|
-
} else {
|
25224
|
-
valueList.push(colValue);
|
25225
25102
|
}
|
25226
|
-
|
25227
|
-
|
25228
|
-
|
25229
|
-
|
25103
|
+
valuesSqlList.push(valueList);
|
25104
|
+
if (valueIndex < values.length - 1) {
|
25105
|
+
valuesSqlList.push(sql`, `);
|
25106
|
+
}
|
25230
25107
|
}
|
25231
25108
|
}
|
25232
25109
|
const withSql = this.buildWithCTE(withList);
|
25233
25110
|
const valuesSql = sql.join(valuesSqlList);
|
25234
25111
|
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
|
25235
25112
|
const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
|
25236
|
-
|
25113
|
+
const overridingSql = overridingSystemValue_ === true ? sql`overriding system value ` : void 0;
|
25114
|
+
return sql`${withSql}insert into ${table4} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}`;
|
25237
25115
|
}
|
25238
25116
|
buildRefreshMaterializedViewQuery({ view: view4, concurrently, withNoData }) {
|
25239
25117
|
const concurrentlySql = concurrently ? sql` concurrently` : void 0;
|
@@ -25969,12 +25847,12 @@ var init_dialect = __esm({
|
|
25969
25847
|
};
|
25970
25848
|
}
|
25971
25849
|
};
|
25972
|
-
__publicField(PgDialect,
|
25850
|
+
__publicField(PgDialect, _a127, "PgDialect");
|
25973
25851
|
}
|
25974
25852
|
});
|
25975
25853
|
|
25976
25854
|
// ../drizzle-orm/dist/selection-proxy.js
|
25977
|
-
var
|
25855
|
+
var _a128, _SelectionProxyHandler, SelectionProxyHandler;
|
25978
25856
|
var init_selection_proxy = __esm({
|
25979
25857
|
"../drizzle-orm/dist/selection-proxy.js"() {
|
25980
25858
|
"use strict";
|
@@ -25984,7 +25862,7 @@ var init_selection_proxy = __esm({
|
|
25984
25862
|
init_sql();
|
25985
25863
|
init_subquery();
|
25986
25864
|
init_view_common();
|
25987
|
-
|
25865
|
+
_a128 = entityKind;
|
25988
25866
|
_SelectionProxyHandler = class _SelectionProxyHandler {
|
25989
25867
|
constructor(config) {
|
25990
25868
|
__publicField(this, "config");
|
@@ -26050,25 +25928,25 @@ var init_selection_proxy = __esm({
|
|
26050
25928
|
return new Proxy(value, new _SelectionProxyHandler(this.config));
|
26051
25929
|
}
|
26052
25930
|
};
|
26053
|
-
__publicField(_SelectionProxyHandler,
|
25931
|
+
__publicField(_SelectionProxyHandler, _a128, "SelectionProxyHandler");
|
26054
25932
|
SelectionProxyHandler = _SelectionProxyHandler;
|
26055
25933
|
}
|
26056
25934
|
});
|
26057
25935
|
|
26058
25936
|
// ../drizzle-orm/dist/query-builders/query-builder.js
|
26059
|
-
var
|
25937
|
+
var _a129, TypedQueryBuilder;
|
26060
25938
|
var init_query_builder = __esm({
|
26061
25939
|
"../drizzle-orm/dist/query-builders/query-builder.js"() {
|
26062
25940
|
"use strict";
|
26063
25941
|
init_entity();
|
26064
|
-
|
25942
|
+
_a129 = entityKind;
|
26065
25943
|
TypedQueryBuilder = class {
|
26066
25944
|
/** @internal */
|
26067
25945
|
getSelectedFields() {
|
26068
25946
|
return this._.selectedFields;
|
26069
25947
|
}
|
26070
25948
|
};
|
26071
|
-
__publicField(TypedQueryBuilder,
|
25949
|
+
__publicField(TypedQueryBuilder, _a129, "TypedQueryBuilder");
|
26072
25950
|
}
|
26073
25951
|
});
|
26074
25952
|
|
@@ -26090,7 +25968,7 @@ function createSetOperator(type, isAll) {
|
|
26090
25968
|
return leftSelect.addSetOperators(setOperators);
|
26091
25969
|
};
|
26092
25970
|
}
|
26093
|
-
var
|
25971
|
+
var _a130, PgSelectBuilder, _a131, _b99, PgSelectQueryBuilderBase, _a132, _b100, PgSelectBase, getPgSetOperators, union, unionAll, intersect, intersectAll, except, exceptAll;
|
26094
25972
|
var init_select2 = __esm({
|
26095
25973
|
"../drizzle-orm/dist/pg-core/query-builders/select.js"() {
|
26096
25974
|
"use strict";
|
@@ -26106,7 +25984,7 @@ var init_select2 = __esm({
|
|
26106
25984
|
init_utils2();
|
26107
25985
|
init_utils2();
|
26108
25986
|
init_view_common();
|
26109
|
-
|
25987
|
+
_a130 = entityKind;
|
26110
25988
|
PgSelectBuilder = class {
|
26111
25989
|
constructor(config) {
|
26112
25990
|
__publicField(this, "fields");
|
@@ -26114,6 +25992,7 @@ var init_select2 = __esm({
|
|
26114
25992
|
__publicField(this, "dialect");
|
26115
25993
|
__publicField(this, "withList", []);
|
26116
25994
|
__publicField(this, "distinct");
|
25995
|
+
__publicField(this, "authToken");
|
26117
25996
|
this.fields = config.fields;
|
26118
25997
|
this.session = config.session;
|
26119
25998
|
this.dialect = config.dialect;
|
@@ -26122,6 +26001,11 @@ var init_select2 = __esm({
|
|
26122
26001
|
}
|
26123
26002
|
this.distinct = config.distinct;
|
26124
26003
|
}
|
26004
|
+
/** @internal */
|
26005
|
+
setToken(token) {
|
26006
|
+
this.authToken = token;
|
26007
|
+
return this;
|
26008
|
+
}
|
26125
26009
|
/**
|
26126
26010
|
* Specify the table, subquery, or other target that you're
|
26127
26011
|
* building a select query against.
|
@@ -26152,11 +26036,11 @@ var init_select2 = __esm({
|
|
26152
26036
|
dialect: this.dialect,
|
26153
26037
|
withList: this.withList,
|
26154
26038
|
distinct: this.distinct
|
26155
|
-
});
|
26039
|
+
}).setToken(this.authToken);
|
26156
26040
|
}
|
26157
26041
|
};
|
26158
|
-
__publicField(PgSelectBuilder,
|
26159
|
-
PgSelectQueryBuilderBase = class extends (
|
26042
|
+
__publicField(PgSelectBuilder, _a130, "PgSelectBuilder");
|
26043
|
+
PgSelectQueryBuilderBase = class extends (_b99 = TypedQueryBuilder, _a131 = entityKind, _b99) {
|
26160
26044
|
constructor({ table: table4, fields, isPartialSelect, session, dialect: dialect4, withList, distinct }) {
|
26161
26045
|
super();
|
26162
26046
|
__publicField(this, "_");
|
@@ -26756,19 +26640,20 @@ var init_select2 = __esm({
|
|
26756
26640
|
return this;
|
26757
26641
|
}
|
26758
26642
|
};
|
26759
|
-
__publicField(PgSelectQueryBuilderBase,
|
26760
|
-
PgSelectBase = class extends (
|
26643
|
+
__publicField(PgSelectQueryBuilderBase, _a131, "PgSelectQueryBuilder");
|
26644
|
+
PgSelectBase = class extends (_b100 = PgSelectQueryBuilderBase, _a132 = entityKind, _b100) {
|
26761
26645
|
constructor() {
|
26762
26646
|
super(...arguments);
|
26647
|
+
__publicField(this, "authToken");
|
26763
26648
|
__publicField(this, "execute", (placeholderValues) => {
|
26764
26649
|
return tracer.startActiveSpan("drizzle.operation", () => {
|
26765
|
-
return this._prepare().execute(placeholderValues);
|
26650
|
+
return this._prepare().execute(placeholderValues, this.authToken);
|
26766
26651
|
});
|
26767
26652
|
});
|
26768
26653
|
}
|
26769
26654
|
/** @internal */
|
26770
26655
|
_prepare(name2) {
|
26771
|
-
const { session, config, dialect: dialect4, joinsNotNullableMap } = this;
|
26656
|
+
const { session, config, dialect: dialect4, joinsNotNullableMap, authToken } = this;
|
26772
26657
|
if (!session) {
|
26773
26658
|
throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
|
26774
26659
|
}
|
@@ -26776,7 +26661,7 @@ var init_select2 = __esm({
|
|
26776
26661
|
const fieldsList = orderSelectedFields(config.fields);
|
26777
26662
|
const query = session.prepareQuery(dialect4.sqlToQuery(this.getSQL()), fieldsList, name2, true);
|
26778
26663
|
query.joinsNotNullableMap = joinsNotNullableMap;
|
26779
|
-
return query;
|
26664
|
+
return query.setToken(authToken);
|
26780
26665
|
});
|
26781
26666
|
}
|
26782
26667
|
/**
|
@@ -26789,8 +26674,13 @@ var init_select2 = __esm({
|
|
26789
26674
|
prepare(name2) {
|
26790
26675
|
return this._prepare(name2);
|
26791
26676
|
}
|
26677
|
+
/** @internal */
|
26678
|
+
setToken(token) {
|
26679
|
+
this.authToken = token;
|
26680
|
+
return this;
|
26681
|
+
}
|
26792
26682
|
};
|
26793
|
-
__publicField(PgSelectBase,
|
26683
|
+
__publicField(PgSelectBase, _a132, "PgSelect");
|
26794
26684
|
applyMixins(PgSelectBase, [QueryPromise]);
|
26795
26685
|
getPgSetOperators = () => ({
|
26796
26686
|
union,
|
@@ -26810,7 +26700,7 @@ var init_select2 = __esm({
|
|
26810
26700
|
});
|
26811
26701
|
|
26812
26702
|
// ../drizzle-orm/dist/pg-core/query-builders/query-builder.js
|
26813
|
-
var
|
26703
|
+
var _a133, QueryBuilder;
|
26814
26704
|
var init_query_builder2 = __esm({
|
26815
26705
|
"../drizzle-orm/dist/pg-core/query-builders/query-builder.js"() {
|
26816
26706
|
"use strict";
|
@@ -26819,7 +26709,7 @@ var init_query_builder2 = __esm({
|
|
26819
26709
|
init_selection_proxy();
|
26820
26710
|
init_subquery();
|
26821
26711
|
init_select2();
|
26822
|
-
|
26712
|
+
_a133 = entityKind;
|
26823
26713
|
QueryBuilder = class {
|
26824
26714
|
constructor(dialect4) {
|
26825
26715
|
__publicField(this, "dialect");
|
@@ -26900,36 +26790,228 @@ var init_query_builder2 = __esm({
|
|
26900
26790
|
return this.dialect;
|
26901
26791
|
}
|
26902
26792
|
};
|
26903
|
-
__publicField(QueryBuilder,
|
26793
|
+
__publicField(QueryBuilder, _a133, "PgQueryBuilder");
|
26904
26794
|
}
|
26905
26795
|
});
|
26906
26796
|
|
26907
|
-
// ../drizzle-orm/dist/pg-core/query-builders/
|
26908
|
-
var
|
26909
|
-
var
|
26910
|
-
"../drizzle-orm/dist/pg-core/query-builders/
|
26797
|
+
// ../drizzle-orm/dist/pg-core/query-builders/insert.js
|
26798
|
+
var _a134, PgInsertBuilder, _a135, _b101, PgInsertBase;
|
26799
|
+
var init_insert = __esm({
|
26800
|
+
"../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
|
26911
26801
|
"use strict";
|
26912
26802
|
init_entity();
|
26913
26803
|
init_query_promise();
|
26804
|
+
init_sql();
|
26805
|
+
init_table();
|
26914
26806
|
init_tracing();
|
26915
|
-
|
26916
|
-
|
26917
|
-
|
26918
|
-
|
26919
|
-
|
26920
|
-
|
26921
|
-
|
26922
|
-
});
|
26923
|
-
});
|
26807
|
+
init_utils2();
|
26808
|
+
init_query_builder2();
|
26809
|
+
_a134 = entityKind;
|
26810
|
+
PgInsertBuilder = class {
|
26811
|
+
constructor(table4, session, dialect4, withList, overridingSystemValue_) {
|
26812
|
+
__publicField(this, "authToken");
|
26813
|
+
this.table = table4;
|
26924
26814
|
this.session = session;
|
26925
26815
|
this.dialect = dialect4;
|
26926
|
-
this.
|
26816
|
+
this.withList = withList;
|
26817
|
+
this.overridingSystemValue_ = overridingSystemValue_;
|
26927
26818
|
}
|
26928
|
-
|
26929
|
-
|
26930
|
-
|
26931
|
-
|
26932
|
-
|
26819
|
+
/** @internal */
|
26820
|
+
setToken(token) {
|
26821
|
+
this.authToken = token;
|
26822
|
+
return this;
|
26823
|
+
}
|
26824
|
+
overridingSystemValue() {
|
26825
|
+
this.overridingSystemValue_ = true;
|
26826
|
+
return this;
|
26827
|
+
}
|
26828
|
+
values(values) {
|
26829
|
+
values = Array.isArray(values) ? values : [values];
|
26830
|
+
if (values.length === 0) {
|
26831
|
+
throw new Error("values() must be called with at least one value");
|
26832
|
+
}
|
26833
|
+
const mappedValues = values.map((entry) => {
|
26834
|
+
const result = {};
|
26835
|
+
const cols = this.table[Table2.Symbol.Columns];
|
26836
|
+
for (const colKey of Object.keys(entry)) {
|
26837
|
+
const colValue = entry[colKey];
|
26838
|
+
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
26839
|
+
}
|
26840
|
+
return result;
|
26841
|
+
});
|
26842
|
+
return new PgInsertBase(
|
26843
|
+
this.table,
|
26844
|
+
mappedValues,
|
26845
|
+
this.session,
|
26846
|
+
this.dialect,
|
26847
|
+
this.withList,
|
26848
|
+
false,
|
26849
|
+
this.overridingSystemValue_
|
26850
|
+
).setToken(this.authToken);
|
26851
|
+
}
|
26852
|
+
select(selectQuery) {
|
26853
|
+
const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
|
26854
|
+
if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
|
26855
|
+
throw new Error(
|
26856
|
+
"Insert select error: selected fields are not the same or are in a different order compared to the table definition"
|
26857
|
+
);
|
26858
|
+
}
|
26859
|
+
return new PgInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
|
26860
|
+
}
|
26861
|
+
};
|
26862
|
+
__publicField(PgInsertBuilder, _a134, "PgInsertBuilder");
|
26863
|
+
PgInsertBase = class extends (_b101 = QueryPromise, _a135 = entityKind, _b101) {
|
26864
|
+
constructor(table4, values, session, dialect4, withList, select, overridingSystemValue_) {
|
26865
|
+
super();
|
26866
|
+
__publicField(this, "config");
|
26867
|
+
__publicField(this, "authToken");
|
26868
|
+
__publicField(this, "execute", (placeholderValues) => {
|
26869
|
+
return tracer.startActiveSpan("drizzle.operation", () => {
|
26870
|
+
return this._prepare().execute(placeholderValues, this.authToken);
|
26871
|
+
});
|
26872
|
+
});
|
26873
|
+
this.session = session;
|
26874
|
+
this.dialect = dialect4;
|
26875
|
+
this.config = { table: table4, values, withList, select, overridingSystemValue_ };
|
26876
|
+
}
|
26877
|
+
returning(fields = this.config.table[Table2.Symbol.Columns]) {
|
26878
|
+
this.config.returning = orderSelectedFields(fields);
|
26879
|
+
return this;
|
26880
|
+
}
|
26881
|
+
/**
|
26882
|
+
* Adds an `on conflict do nothing` clause to the query.
|
26883
|
+
*
|
26884
|
+
* Calling this method simply avoids inserting a row as its alternative action.
|
26885
|
+
*
|
26886
|
+
* See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
|
26887
|
+
*
|
26888
|
+
* @param config The `target` and `where` clauses.
|
26889
|
+
*
|
26890
|
+
* @example
|
26891
|
+
* ```ts
|
26892
|
+
* // Insert one row and cancel the insert if there's a conflict
|
26893
|
+
* await db.insert(cars)
|
26894
|
+
* .values({ id: 1, brand: 'BMW' })
|
26895
|
+
* .onConflictDoNothing();
|
26896
|
+
*
|
26897
|
+
* // Explicitly specify conflict target
|
26898
|
+
* await db.insert(cars)
|
26899
|
+
* .values({ id: 1, brand: 'BMW' })
|
26900
|
+
* .onConflictDoNothing({ target: cars.id });
|
26901
|
+
* ```
|
26902
|
+
*/
|
26903
|
+
onConflictDoNothing(config = {}) {
|
26904
|
+
if (config.target === void 0) {
|
26905
|
+
this.config.onConflict = sql`do nothing`;
|
26906
|
+
} else {
|
26907
|
+
let targetColumn = "";
|
26908
|
+
targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
|
26909
|
+
const whereSql = config.where ? sql` where ${config.where}` : void 0;
|
26910
|
+
this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
|
26911
|
+
}
|
26912
|
+
return this;
|
26913
|
+
}
|
26914
|
+
/**
|
26915
|
+
* Adds an `on conflict do update` clause to the query.
|
26916
|
+
*
|
26917
|
+
* Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
|
26918
|
+
*
|
26919
|
+
* See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
|
26920
|
+
*
|
26921
|
+
* @param config The `target`, `set` and `where` clauses.
|
26922
|
+
*
|
26923
|
+
* @example
|
26924
|
+
* ```ts
|
26925
|
+
* // Update the row if there's a conflict
|
26926
|
+
* await db.insert(cars)
|
26927
|
+
* .values({ id: 1, brand: 'BMW' })
|
26928
|
+
* .onConflictDoUpdate({
|
26929
|
+
* target: cars.id,
|
26930
|
+
* set: { brand: 'Porsche' }
|
26931
|
+
* });
|
26932
|
+
*
|
26933
|
+
* // Upsert with 'where' clause
|
26934
|
+
* await db.insert(cars)
|
26935
|
+
* .values({ id: 1, brand: 'BMW' })
|
26936
|
+
* .onConflictDoUpdate({
|
26937
|
+
* target: cars.id,
|
26938
|
+
* set: { brand: 'newBMW' },
|
26939
|
+
* targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
|
26940
|
+
* });
|
26941
|
+
* ```
|
26942
|
+
*/
|
26943
|
+
onConflictDoUpdate(config) {
|
26944
|
+
if (config.where && (config.targetWhere || config.setWhere)) {
|
26945
|
+
throw new Error(
|
26946
|
+
'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
|
26947
|
+
);
|
26948
|
+
}
|
26949
|
+
const whereSql = config.where ? sql` where ${config.where}` : void 0;
|
26950
|
+
const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
|
26951
|
+
const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
|
26952
|
+
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
26953
|
+
let targetColumn = "";
|
26954
|
+
targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
|
26955
|
+
this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
|
26956
|
+
return this;
|
26957
|
+
}
|
26958
|
+
/** @internal */
|
26959
|
+
getSQL() {
|
26960
|
+
return this.dialect.buildInsertQuery(this.config);
|
26961
|
+
}
|
26962
|
+
toSQL() {
|
26963
|
+
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
26964
|
+
return rest;
|
26965
|
+
}
|
26966
|
+
/** @internal */
|
26967
|
+
_prepare(name2) {
|
26968
|
+
return tracer.startActiveSpan("drizzle.prepareQuery", () => {
|
26969
|
+
return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
|
26970
|
+
});
|
26971
|
+
}
|
26972
|
+
prepare(name2) {
|
26973
|
+
return this._prepare(name2);
|
26974
|
+
}
|
26975
|
+
/** @internal */
|
26976
|
+
setToken(token) {
|
26977
|
+
this.authToken = token;
|
26978
|
+
return this;
|
26979
|
+
}
|
26980
|
+
$dynamic() {
|
26981
|
+
return this;
|
26982
|
+
}
|
26983
|
+
};
|
26984
|
+
__publicField(PgInsertBase, _a135, "PgInsert");
|
26985
|
+
}
|
26986
|
+
});
|
26987
|
+
|
26988
|
+
// ../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js
|
26989
|
+
var _a136, _b102, PgRefreshMaterializedView;
|
26990
|
+
var init_refresh_materialized_view = __esm({
|
26991
|
+
"../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js"() {
|
26992
|
+
"use strict";
|
26993
|
+
init_entity();
|
26994
|
+
init_query_promise();
|
26995
|
+
init_tracing();
|
26996
|
+
PgRefreshMaterializedView = class extends (_b102 = QueryPromise, _a136 = entityKind, _b102) {
|
26997
|
+
constructor(view4, session, dialect4) {
|
26998
|
+
super();
|
26999
|
+
__publicField(this, "config");
|
27000
|
+
__publicField(this, "authToken");
|
27001
|
+
__publicField(this, "execute", (placeholderValues) => {
|
27002
|
+
return tracer.startActiveSpan("drizzle.operation", () => {
|
27003
|
+
return this._prepare().execute(placeholderValues, this.authToken);
|
27004
|
+
});
|
27005
|
+
});
|
27006
|
+
this.session = session;
|
27007
|
+
this.dialect = dialect4;
|
27008
|
+
this.config = { view: view4 };
|
27009
|
+
}
|
27010
|
+
concurrently() {
|
27011
|
+
if (this.config.withNoData !== void 0) {
|
27012
|
+
throw new Error("Cannot use concurrently and withNoData together");
|
27013
|
+
}
|
27014
|
+
this.config.concurrently = true;
|
26933
27015
|
return this;
|
26934
27016
|
}
|
26935
27017
|
withNoData() {
|
@@ -26956,6 +27038,11 @@ var init_refresh_materialized_view = __esm({
|
|
26956
27038
|
prepare(name2) {
|
26957
27039
|
return this._prepare(name2);
|
26958
27040
|
}
|
27041
|
+
/** @internal */
|
27042
|
+
setToken(token) {
|
27043
|
+
this.authToken = token;
|
27044
|
+
return this;
|
27045
|
+
}
|
26959
27046
|
};
|
26960
27047
|
__publicField(PgRefreshMaterializedView, _a136, "PgRefreshMaterializedView");
|
26961
27048
|
}
|
@@ -26974,17 +27061,27 @@ var init_update = __esm({
|
|
26974
27061
|
"../drizzle-orm/dist/pg-core/query-builders/update.js"() {
|
26975
27062
|
"use strict";
|
26976
27063
|
init_entity();
|
27064
|
+
init_table2();
|
26977
27065
|
init_query_promise();
|
27066
|
+
init_selection_proxy();
|
27067
|
+
init_sql();
|
27068
|
+
init_subquery();
|
26978
27069
|
init_table();
|
26979
27070
|
init_utils2();
|
27071
|
+
init_view_common();
|
26980
27072
|
_a137 = entityKind;
|
26981
27073
|
PgUpdateBuilder = class {
|
26982
27074
|
constructor(table4, session, dialect4, withList) {
|
27075
|
+
__publicField(this, "authToken");
|
26983
27076
|
this.table = table4;
|
26984
27077
|
this.session = session;
|
26985
27078
|
this.dialect = dialect4;
|
26986
27079
|
this.withList = withList;
|
26987
27080
|
}
|
27081
|
+
setToken(token) {
|
27082
|
+
this.authToken = token;
|
27083
|
+
return this;
|
27084
|
+
}
|
26988
27085
|
set(values) {
|
26989
27086
|
return new PgUpdateBase(
|
26990
27087
|
this.table,
|
@@ -26992,7 +27089,7 @@ var init_update = __esm({
|
|
26992
27089
|
this.session,
|
26993
27090
|
this.dialect,
|
26994
27091
|
this.withList
|
26995
|
-
);
|
27092
|
+
).setToken(this.authToken);
|
26996
27093
|
}
|
26997
27094
|
};
|
26998
27095
|
__publicField(PgUpdateBuilder, _a137, "PgUpdateBuilder");
|
@@ -27000,12 +27097,86 @@ var init_update = __esm({
|
|
27000
27097
|
constructor(table4, set, session, dialect4, withList) {
|
27001
27098
|
super();
|
27002
27099
|
__publicField(this, "config");
|
27100
|
+
__publicField(this, "tableName");
|
27101
|
+
__publicField(this, "joinsNotNullableMap");
|
27102
|
+
__publicField(this, "leftJoin", this.createJoin("left"));
|
27103
|
+
__publicField(this, "rightJoin", this.createJoin("right"));
|
27104
|
+
__publicField(this, "innerJoin", this.createJoin("inner"));
|
27105
|
+
__publicField(this, "fullJoin", this.createJoin("full"));
|
27106
|
+
__publicField(this, "authToken");
|
27003
27107
|
__publicField(this, "execute", (placeholderValues) => {
|
27004
|
-
return this._prepare().execute(placeholderValues);
|
27108
|
+
return this._prepare().execute(placeholderValues, this.authToken);
|
27005
27109
|
});
|
27006
27110
|
this.session = session;
|
27007
27111
|
this.dialect = dialect4;
|
27008
|
-
this.config = { set, table: table4, withList };
|
27112
|
+
this.config = { set, table: table4, withList, joins: [] };
|
27113
|
+
this.tableName = getTableLikeName(table4);
|
27114
|
+
this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
|
27115
|
+
}
|
27116
|
+
from(source) {
|
27117
|
+
const tableName = getTableLikeName(source);
|
27118
|
+
if (typeof tableName === "string") {
|
27119
|
+
this.joinsNotNullableMap[tableName] = true;
|
27120
|
+
}
|
27121
|
+
this.config.from = source;
|
27122
|
+
return this;
|
27123
|
+
}
|
27124
|
+
getTableLikeFields(table4) {
|
27125
|
+
if (is(table4, PgTable)) {
|
27126
|
+
return table4[Table2.Symbol.Columns];
|
27127
|
+
} else if (is(table4, Subquery)) {
|
27128
|
+
return table4._.selectedFields;
|
27129
|
+
}
|
27130
|
+
return table4[ViewBaseConfig].selectedFields;
|
27131
|
+
}
|
27132
|
+
createJoin(joinType) {
|
27133
|
+
return (table4, on) => {
|
27134
|
+
const tableName = getTableLikeName(table4);
|
27135
|
+
if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
|
27136
|
+
throw new Error(`Alias "${tableName}" is already used in this query`);
|
27137
|
+
}
|
27138
|
+
if (typeof on === "function") {
|
27139
|
+
const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;
|
27140
|
+
on = on(
|
27141
|
+
new Proxy(
|
27142
|
+
this.config.table[Table2.Symbol.Columns],
|
27143
|
+
new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
|
27144
|
+
),
|
27145
|
+
from && new Proxy(
|
27146
|
+
from,
|
27147
|
+
new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
|
27148
|
+
)
|
27149
|
+
);
|
27150
|
+
}
|
27151
|
+
this.config.joins.push({ on, table: table4, joinType, alias: tableName });
|
27152
|
+
if (typeof tableName === "string") {
|
27153
|
+
switch (joinType) {
|
27154
|
+
case "left": {
|
27155
|
+
this.joinsNotNullableMap[tableName] = false;
|
27156
|
+
break;
|
27157
|
+
}
|
27158
|
+
case "right": {
|
27159
|
+
this.joinsNotNullableMap = Object.fromEntries(
|
27160
|
+
Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
|
27161
|
+
);
|
27162
|
+
this.joinsNotNullableMap[tableName] = true;
|
27163
|
+
break;
|
27164
|
+
}
|
27165
|
+
case "inner": {
|
27166
|
+
this.joinsNotNullableMap[tableName] = true;
|
27167
|
+
break;
|
27168
|
+
}
|
27169
|
+
case "full": {
|
27170
|
+
this.joinsNotNullableMap = Object.fromEntries(
|
27171
|
+
Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
|
27172
|
+
);
|
27173
|
+
this.joinsNotNullableMap[tableName] = false;
|
27174
|
+
break;
|
27175
|
+
}
|
27176
|
+
}
|
27177
|
+
}
|
27178
|
+
return this;
|
27179
|
+
};
|
27009
27180
|
}
|
27010
27181
|
/**
|
27011
27182
|
* Adds a 'where' clause to the query.
|
@@ -27044,7 +27215,24 @@ var init_update = __esm({
|
|
27044
27215
|
this.config.where = where;
|
27045
27216
|
return this;
|
27046
27217
|
}
|
27047
|
-
returning(fields
|
27218
|
+
returning(fields) {
|
27219
|
+
if (!fields) {
|
27220
|
+
fields = Object.assign({}, this.config.table[Table2.Symbol.Columns]);
|
27221
|
+
if (this.config.from) {
|
27222
|
+
const tableName = getTableLikeName(this.config.from);
|
27223
|
+
if (typeof tableName === "string" && this.config.from && !is(this.config.from, SQL)) {
|
27224
|
+
const fromFields = this.getTableLikeFields(this.config.from);
|
27225
|
+
fields[tableName] = fromFields;
|
27226
|
+
}
|
27227
|
+
for (const join of this.config.joins) {
|
27228
|
+
const tableName2 = getTableLikeName(join.table);
|
27229
|
+
if (typeof tableName2 === "string" && !is(join.table, SQL)) {
|
27230
|
+
const fromFields = this.getTableLikeFields(join.table);
|
27231
|
+
fields[tableName2] = fromFields;
|
27232
|
+
}
|
27233
|
+
}
|
27234
|
+
}
|
27235
|
+
}
|
27048
27236
|
this.config.returning = orderSelectedFields(fields);
|
27049
27237
|
return this;
|
27050
27238
|
}
|
@@ -27058,11 +27246,18 @@ var init_update = __esm({
|
|
27058
27246
|
}
|
27059
27247
|
/** @internal */
|
27060
27248
|
_prepare(name2) {
|
27061
|
-
|
27249
|
+
const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
|
27250
|
+
query.joinsNotNullableMap = this.joinsNotNullableMap;
|
27251
|
+
return query;
|
27062
27252
|
}
|
27063
27253
|
prepare(name2) {
|
27064
27254
|
return this._prepare(name2);
|
27065
27255
|
}
|
27256
|
+
/** @internal */
|
27257
|
+
setToken(token) {
|
27258
|
+
this.authToken = token;
|
27259
|
+
return this;
|
27260
|
+
}
|
27066
27261
|
$dynamic() {
|
27067
27262
|
return this;
|
27068
27263
|
}
|
@@ -27096,6 +27291,7 @@ var init_count = __esm({
|
|
27096
27291
|
constructor(params) {
|
27097
27292
|
super(_PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
|
27098
27293
|
__publicField(this, "sql");
|
27294
|
+
__publicField(this, "token");
|
27099
27295
|
__publicField(this, _a139, "PgCountBuilder");
|
27100
27296
|
__publicField(this, "session");
|
27101
27297
|
this.params = params;
|
@@ -27112,8 +27308,13 @@ var init_count = __esm({
|
|
27112
27308
|
static buildCount(source, filters) {
|
27113
27309
|
return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters};`;
|
27114
27310
|
}
|
27311
|
+
/** @intrnal */
|
27312
|
+
setToken(token) {
|
27313
|
+
this.token = token;
|
27314
|
+
return this;
|
27315
|
+
}
|
27115
27316
|
then(onfulfilled, onrejected) {
|
27116
|
-
return Promise.resolve(this.session.count(this.sql)).then(
|
27317
|
+
return Promise.resolve(this.session.count(this.sql, this.token)).then(
|
27117
27318
|
onfulfilled,
|
27118
27319
|
onrejected
|
27119
27320
|
);
|
@@ -27190,6 +27391,7 @@ var init_query = __esm({
|
|
27190
27391
|
PgRelationalQuery = class extends (_b105 = QueryPromise, _a141 = entityKind, _b105) {
|
27191
27392
|
constructor(fullSchema, schema4, tableNamesMap, table4, tableConfig, dialect4, session, config, mode) {
|
27192
27393
|
super();
|
27394
|
+
__publicField(this, "authToken");
|
27193
27395
|
this.fullSchema = fullSchema;
|
27194
27396
|
this.schema = schema4;
|
27195
27397
|
this.tableNamesMap = tableNamesMap;
|
@@ -27247,9 +27449,14 @@ var init_query = __esm({
|
|
27247
27449
|
toSQL() {
|
27248
27450
|
return this._toSQL().builtQuery;
|
27249
27451
|
}
|
27452
|
+
/** @internal */
|
27453
|
+
setToken(token) {
|
27454
|
+
this.authToken = token;
|
27455
|
+
return this;
|
27456
|
+
}
|
27250
27457
|
execute() {
|
27251
27458
|
return tracer.startActiveSpan("drizzle.operation", () => {
|
27252
|
-
return this._prepare().execute();
|
27459
|
+
return this._prepare().execute(void 0, this.authToken);
|
27253
27460
|
});
|
27254
27461
|
}
|
27255
27462
|
};
|
@@ -27312,6 +27519,7 @@ var init_db = __esm({
|
|
27312
27519
|
PgDatabase = class {
|
27313
27520
|
constructor(dialect4, session, schema4) {
|
27314
27521
|
__publicField(this, "query");
|
27522
|
+
__publicField(this, "authToken");
|
27315
27523
|
this.dialect = dialect4;
|
27316
27524
|
this.session = session;
|
27317
27525
|
this._ = schema4 ? {
|
@@ -27567,7 +27775,7 @@ var init_db = __esm({
|
|
27567
27775
|
false
|
27568
27776
|
);
|
27569
27777
|
return new PgRaw(
|
27570
|
-
() => prepared.execute(),
|
27778
|
+
() => prepared.execute(void 0, this.authToken),
|
27571
27779
|
sequel,
|
27572
27780
|
builtQuery,
|
27573
27781
|
(result) => prepared.mapResult(result, true)
|
@@ -28112,6 +28320,7 @@ var init_session = __esm({
|
|
28112
28320
|
_a159 = entityKind;
|
28113
28321
|
PgPreparedQuery = class {
|
28114
28322
|
constructor(query) {
|
28323
|
+
__publicField(this, "authToken");
|
28115
28324
|
/** @internal */
|
28116
28325
|
__publicField(this, "joinsNotNullableMap");
|
28117
28326
|
this.query = query;
|
@@ -28122,6 +28331,11 @@ var init_session = __esm({
|
|
28122
28331
|
mapResult(response, _isFromBatch) {
|
28123
28332
|
return response;
|
28124
28333
|
}
|
28334
|
+
/** @internal */
|
28335
|
+
setToken(token) {
|
28336
|
+
this.authToken = token;
|
28337
|
+
return this;
|
28338
|
+
}
|
28125
28339
|
};
|
28126
28340
|
__publicField(PgPreparedQuery, _a159, "PgPreparedQuery");
|
28127
28341
|
_a160 = entityKind;
|
@@ -28129,7 +28343,8 @@ var init_session = __esm({
|
|
28129
28343
|
constructor(dialect4) {
|
28130
28344
|
this.dialect = dialect4;
|
28131
28345
|
}
|
28132
|
-
|
28346
|
+
/** @internal */
|
28347
|
+
execute(query, token) {
|
28133
28348
|
return tracer.startActiveSpan("drizzle.operation", () => {
|
28134
28349
|
const prepared = tracer.startActiveSpan("drizzle.prepareQuery", () => {
|
28135
28350
|
return this.prepareQuery(
|
@@ -28139,7 +28354,7 @@ var init_session = __esm({
|
|
28139
28354
|
false
|
28140
28355
|
);
|
28141
28356
|
});
|
28142
|
-
return prepared.execute();
|
28357
|
+
return prepared.setToken(token).execute(void 0, token);
|
28143
28358
|
});
|
28144
28359
|
}
|
28145
28360
|
all(query) {
|
@@ -28150,8 +28365,9 @@ var init_session = __esm({
|
|
28150
28365
|
false
|
28151
28366
|
).all();
|
28152
28367
|
}
|
28153
|
-
|
28154
|
-
|
28368
|
+
/** @internal */
|
28369
|
+
async count(sql2, token) {
|
28370
|
+
const res = await this.execute(sql2, token);
|
28155
28371
|
return Number(
|
28156
28372
|
res[0]["count"]
|
28157
28373
|
);
|
@@ -30785,180 +31001,12 @@ var init_delete2 = __esm({
|
|
30785
31001
|
return this;
|
30786
31002
|
}
|
30787
31003
|
returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
|
30788
|
-
this.config.returning = orderSelectedFields(fields);
|
30789
|
-
return this;
|
30790
|
-
}
|
30791
|
-
/** @internal */
|
30792
|
-
getSQL() {
|
30793
|
-
return this.dialect.buildDeleteQuery(this.config);
|
30794
|
-
}
|
30795
|
-
toSQL() {
|
30796
|
-
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
30797
|
-
return rest;
|
30798
|
-
}
|
30799
|
-
/** @internal */
|
30800
|
-
_prepare(isOneTimeQuery = true) {
|
30801
|
-
return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
|
30802
|
-
this.dialect.sqlToQuery(this.getSQL()),
|
30803
|
-
this.config.returning,
|
30804
|
-
this.config.returning ? "all" : "run",
|
30805
|
-
true
|
30806
|
-
);
|
30807
|
-
}
|
30808
|
-
prepare() {
|
30809
|
-
return this._prepare(false);
|
30810
|
-
}
|
30811
|
-
async execute(placeholderValues) {
|
30812
|
-
return this._prepare().execute(placeholderValues);
|
30813
|
-
}
|
30814
|
-
$dynamic() {
|
30815
|
-
return this;
|
30816
|
-
}
|
30817
|
-
};
|
30818
|
-
__publicField(SQLiteDeleteBase, _a196, "SQLiteDelete");
|
30819
|
-
}
|
30820
|
-
});
|
30821
|
-
|
30822
|
-
// ../drizzle-orm/dist/sqlite-core/query-builders/insert.js
|
30823
|
-
var _a197, SQLiteInsertBuilder, _a198, _b142, SQLiteInsertBase;
|
30824
|
-
var init_insert2 = __esm({
|
30825
|
-
"../drizzle-orm/dist/sqlite-core/query-builders/insert.js"() {
|
30826
|
-
"use strict";
|
30827
|
-
init_entity();
|
30828
|
-
init_query_promise();
|
30829
|
-
init_sql();
|
30830
|
-
init_table3();
|
30831
|
-
init_table();
|
30832
|
-
init_utils2();
|
30833
|
-
_a197 = entityKind;
|
30834
|
-
SQLiteInsertBuilder = class {
|
30835
|
-
constructor(table4, session, dialect4, withList) {
|
30836
|
-
this.table = table4;
|
30837
|
-
this.session = session;
|
30838
|
-
this.dialect = dialect4;
|
30839
|
-
this.withList = withList;
|
30840
|
-
}
|
30841
|
-
values(values) {
|
30842
|
-
values = Array.isArray(values) ? values : [values];
|
30843
|
-
if (values.length === 0) {
|
30844
|
-
throw new Error("values() must be called with at least one value");
|
30845
|
-
}
|
30846
|
-
const mappedValues = values.map((entry) => {
|
30847
|
-
const result = {};
|
30848
|
-
const cols = this.table[Table2.Symbol.Columns];
|
30849
|
-
for (const colKey of Object.keys(entry)) {
|
30850
|
-
const colValue = entry[colKey];
|
30851
|
-
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
30852
|
-
}
|
30853
|
-
return result;
|
30854
|
-
});
|
30855
|
-
return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
|
30856
|
-
}
|
30857
|
-
};
|
30858
|
-
__publicField(SQLiteInsertBuilder, _a197, "SQLiteInsertBuilder");
|
30859
|
-
SQLiteInsertBase = class extends (_b142 = QueryPromise, _a198 = entityKind, _b142) {
|
30860
|
-
constructor(table4, values, session, dialect4, withList) {
|
30861
|
-
super();
|
30862
|
-
/** @internal */
|
30863
|
-
__publicField(this, "config");
|
30864
|
-
__publicField(this, "run", (placeholderValues) => {
|
30865
|
-
return this._prepare().run(placeholderValues);
|
30866
|
-
});
|
30867
|
-
__publicField(this, "all", (placeholderValues) => {
|
30868
|
-
return this._prepare().all(placeholderValues);
|
30869
|
-
});
|
30870
|
-
__publicField(this, "get", (placeholderValues) => {
|
30871
|
-
return this._prepare().get(placeholderValues);
|
30872
|
-
});
|
30873
|
-
__publicField(this, "values", (placeholderValues) => {
|
30874
|
-
return this._prepare().values(placeholderValues);
|
30875
|
-
});
|
30876
|
-
this.session = session;
|
30877
|
-
this.dialect = dialect4;
|
30878
|
-
this.config = { table: table4, values, withList };
|
30879
|
-
}
|
30880
|
-
returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
|
30881
|
-
this.config.returning = orderSelectedFields(fields);
|
30882
|
-
return this;
|
30883
|
-
}
|
30884
|
-
/**
|
30885
|
-
* Adds an `on conflict do nothing` clause to the query.
|
30886
|
-
*
|
30887
|
-
* Calling this method simply avoids inserting a row as its alternative action.
|
30888
|
-
*
|
30889
|
-
* See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
|
30890
|
-
*
|
30891
|
-
* @param config The `target` and `where` clauses.
|
30892
|
-
*
|
30893
|
-
* @example
|
30894
|
-
* ```ts
|
30895
|
-
* // Insert one row and cancel the insert if there's a conflict
|
30896
|
-
* await db.insert(cars)
|
30897
|
-
* .values({ id: 1, brand: 'BMW' })
|
30898
|
-
* .onConflictDoNothing();
|
30899
|
-
*
|
30900
|
-
* // Explicitly specify conflict target
|
30901
|
-
* await db.insert(cars)
|
30902
|
-
* .values({ id: 1, brand: 'BMW' })
|
30903
|
-
* .onConflictDoNothing({ target: cars.id });
|
30904
|
-
* ```
|
30905
|
-
*/
|
30906
|
-
onConflictDoNothing(config = {}) {
|
30907
|
-
if (config.target === void 0) {
|
30908
|
-
this.config.onConflict = sql`do nothing`;
|
30909
|
-
} else {
|
30910
|
-
const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
|
30911
|
-
const whereSql = config.where ? sql` where ${config.where}` : sql``;
|
30912
|
-
this.config.onConflict = sql`${targetSql} do nothing${whereSql}`;
|
30913
|
-
}
|
30914
|
-
return this;
|
30915
|
-
}
|
30916
|
-
/**
|
30917
|
-
* Adds an `on conflict do update` clause to the query.
|
30918
|
-
*
|
30919
|
-
* Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
|
30920
|
-
*
|
30921
|
-
* See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
|
30922
|
-
*
|
30923
|
-
* @param config The `target`, `set` and `where` clauses.
|
30924
|
-
*
|
30925
|
-
* @example
|
30926
|
-
* ```ts
|
30927
|
-
* // Update the row if there's a conflict
|
30928
|
-
* await db.insert(cars)
|
30929
|
-
* .values({ id: 1, brand: 'BMW' })
|
30930
|
-
* .onConflictDoUpdate({
|
30931
|
-
* target: cars.id,
|
30932
|
-
* set: { brand: 'Porsche' }
|
30933
|
-
* });
|
30934
|
-
*
|
30935
|
-
* // Upsert with 'where' clause
|
30936
|
-
* await db.insert(cars)
|
30937
|
-
* .values({ id: 1, brand: 'BMW' })
|
30938
|
-
* .onConflictDoUpdate({
|
30939
|
-
* target: cars.id,
|
30940
|
-
* set: { brand: 'newBMW' },
|
30941
|
-
* where: sql`${cars.createdAt} > '2023-01-01'::date`,
|
30942
|
-
* });
|
30943
|
-
* ```
|
30944
|
-
*/
|
30945
|
-
onConflictDoUpdate(config) {
|
30946
|
-
if (config.where && (config.targetWhere || config.setWhere)) {
|
30947
|
-
throw new Error(
|
30948
|
-
'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
|
30949
|
-
);
|
30950
|
-
}
|
30951
|
-
const whereSql = config.where ? sql` where ${config.where}` : void 0;
|
30952
|
-
const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
|
30953
|
-
const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
|
30954
|
-
const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
|
30955
|
-
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
30956
|
-
this.config.onConflict = sql`${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
|
31004
|
+
this.config.returning = orderSelectedFields(fields);
|
30957
31005
|
return this;
|
30958
31006
|
}
|
30959
31007
|
/** @internal */
|
30960
31008
|
getSQL() {
|
30961
|
-
return this.dialect.
|
31009
|
+
return this.dialect.buildDeleteQuery(this.config);
|
30962
31010
|
}
|
30963
31011
|
toSQL() {
|
30964
31012
|
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
@@ -30976,32 +31024,32 @@ var init_insert2 = __esm({
|
|
30976
31024
|
prepare() {
|
30977
31025
|
return this._prepare(false);
|
30978
31026
|
}
|
30979
|
-
async execute() {
|
30980
|
-
return this.
|
31027
|
+
async execute(placeholderValues) {
|
31028
|
+
return this._prepare().execute(placeholderValues);
|
30981
31029
|
}
|
30982
31030
|
$dynamic() {
|
30983
31031
|
return this;
|
30984
31032
|
}
|
30985
31033
|
};
|
30986
|
-
__publicField(
|
31034
|
+
__publicField(SQLiteDeleteBase, _a196, "SQLiteDelete");
|
30987
31035
|
}
|
30988
31036
|
});
|
30989
31037
|
|
30990
31038
|
// ../drizzle-orm/dist/sqlite-core/view-base.js
|
30991
|
-
var
|
31039
|
+
var _a197, _b142, SQLiteViewBase;
|
30992
31040
|
var init_view_base2 = __esm({
|
30993
31041
|
"../drizzle-orm/dist/sqlite-core/view-base.js"() {
|
30994
31042
|
"use strict";
|
30995
31043
|
init_entity();
|
30996
31044
|
init_sql();
|
30997
|
-
SQLiteViewBase = class extends (
|
31045
|
+
SQLiteViewBase = class extends (_b142 = View3, _a197 = entityKind, _b142) {
|
30998
31046
|
};
|
30999
|
-
__publicField(SQLiteViewBase,
|
31047
|
+
__publicField(SQLiteViewBase, _a197, "SQLiteViewBase");
|
31000
31048
|
}
|
31001
31049
|
});
|
31002
31050
|
|
31003
31051
|
// ../drizzle-orm/dist/sqlite-core/dialect.js
|
31004
|
-
var
|
31052
|
+
var _a198, SQLiteDialect, _a199, _b143, SQLiteSyncDialect, _a200, _b144, SQLiteAsyncDialect;
|
31005
31053
|
var init_dialect2 = __esm({
|
31006
31054
|
"../drizzle-orm/dist/sqlite-core/dialect.js"() {
|
31007
31055
|
"use strict";
|
@@ -31020,7 +31068,7 @@ var init_dialect2 = __esm({
|
|
31020
31068
|
init_utils2();
|
31021
31069
|
init_view_common();
|
31022
31070
|
init_view_base2();
|
31023
|
-
|
31071
|
+
_a198 = entityKind;
|
31024
31072
|
SQLiteDialect = class {
|
31025
31073
|
constructor(config) {
|
31026
31074
|
/** @internal */
|
@@ -31073,14 +31121,16 @@ var init_dialect2 = __esm({
|
|
31073
31121
|
return [res];
|
31074
31122
|
}));
|
31075
31123
|
}
|
31076
|
-
buildUpdateQuery({ table: table4, set, where, returning, withList, limit, orderBy }) {
|
31124
|
+
buildUpdateQuery({ table: table4, set, where, returning, withList, joins, from, limit, orderBy }) {
|
31077
31125
|
const withSql = this.buildWithCTE(withList);
|
31078
31126
|
const setSql = this.buildUpdateSet(table4, set);
|
31127
|
+
const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
|
31128
|
+
const joinsSql = this.buildJoins(joins);
|
31079
31129
|
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
|
31080
31130
|
const whereSql = where ? sql` where ${where}` : void 0;
|
31081
31131
|
const orderBySql = this.buildOrderBy(orderBy);
|
31082
31132
|
const limitSql = this.buildLimit(limit);
|
31083
|
-
return sql`${withSql}update ${table4} set ${setSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
|
31133
|
+
return sql`${withSql}update ${table4} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
|
31084
31134
|
}
|
31085
31135
|
/**
|
31086
31136
|
* Builds selection SQL with provided fields/expressions
|
@@ -31133,6 +31183,37 @@ var init_dialect2 = __esm({
|
|
31133
31183
|
});
|
31134
31184
|
return sql.join(chunks);
|
31135
31185
|
}
|
31186
|
+
buildJoins(joins) {
|
31187
|
+
if (!joins || joins.length === 0) {
|
31188
|
+
return void 0;
|
31189
|
+
}
|
31190
|
+
const joinsArray = [];
|
31191
|
+
if (joins) {
|
31192
|
+
for (const [index4, joinMeta] of joins.entries()) {
|
31193
|
+
if (index4 === 0) {
|
31194
|
+
joinsArray.push(sql` `);
|
31195
|
+
}
|
31196
|
+
const table4 = joinMeta.table;
|
31197
|
+
if (is(table4, SQLiteTable)) {
|
31198
|
+
const tableName = table4[SQLiteTable.Symbol.Name];
|
31199
|
+
const tableSchema = table4[SQLiteTable.Symbol.Schema];
|
31200
|
+
const origTableName = table4[SQLiteTable.Symbol.OriginalName];
|
31201
|
+
const alias = tableName === origTableName ? void 0 : joinMeta.alias;
|
31202
|
+
joinsArray.push(
|
31203
|
+
sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
|
31204
|
+
);
|
31205
|
+
} else {
|
31206
|
+
joinsArray.push(
|
31207
|
+
sql`${sql.raw(joinMeta.joinType)} join ${table4} on ${joinMeta.on}`
|
31208
|
+
);
|
31209
|
+
}
|
31210
|
+
if (index4 < joins.length - 1) {
|
31211
|
+
joinsArray.push(sql` `);
|
31212
|
+
}
|
31213
|
+
}
|
31214
|
+
}
|
31215
|
+
return sql.join(joinsArray);
|
31216
|
+
}
|
31136
31217
|
buildLimit(limit) {
|
31137
31218
|
return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
|
31138
31219
|
}
|
@@ -31148,6 +31229,12 @@ var init_dialect2 = __esm({
|
|
31148
31229
|
}
|
31149
31230
|
return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : void 0;
|
31150
31231
|
}
|
31232
|
+
buildFromTable(table4) {
|
31233
|
+
if (is(table4, Table2) && table4[Table2.Symbol.OriginalName] !== table4[Table2.Symbol.Name]) {
|
31234
|
+
return sql`${sql.identifier(table4[Table2.Symbol.OriginalName])} ${sql.identifier(table4[Table2.Symbol.Name])}`;
|
31235
|
+
}
|
31236
|
+
return table4;
|
31237
|
+
}
|
31151
31238
|
buildSelectQuery({
|
31152
31239
|
withList,
|
31153
31240
|
fields,
|
@@ -31178,38 +31265,8 @@ var init_dialect2 = __esm({
|
|
31178
31265
|
const withSql = this.buildWithCTE(withList);
|
31179
31266
|
const distinctSql = distinct ? sql` distinct` : void 0;
|
31180
31267
|
const selection = this.buildSelection(fieldsList, { isSingleTable });
|
31181
|
-
const tableSql = (
|
31182
|
-
|
31183
|
-
return sql`${sql.identifier(table4[Table2.Symbol.OriginalName])} ${sql.identifier(table4[Table2.Symbol.Name])}`;
|
31184
|
-
}
|
31185
|
-
return table4;
|
31186
|
-
})();
|
31187
|
-
const joinsArray = [];
|
31188
|
-
if (joins) {
|
31189
|
-
for (const [index4, joinMeta] of joins.entries()) {
|
31190
|
-
if (index4 === 0) {
|
31191
|
-
joinsArray.push(sql` `);
|
31192
|
-
}
|
31193
|
-
const table22 = joinMeta.table;
|
31194
|
-
if (is(table22, SQLiteTable)) {
|
31195
|
-
const tableName = table22[SQLiteTable.Symbol.Name];
|
31196
|
-
const tableSchema = table22[SQLiteTable.Symbol.Schema];
|
31197
|
-
const origTableName = table22[SQLiteTable.Symbol.OriginalName];
|
31198
|
-
const alias = tableName === origTableName ? void 0 : joinMeta.alias;
|
31199
|
-
joinsArray.push(
|
31200
|
-
sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
|
31201
|
-
);
|
31202
|
-
} else {
|
31203
|
-
joinsArray.push(
|
31204
|
-
sql`${sql.raw(joinMeta.joinType)} join ${table22} on ${joinMeta.on}`
|
31205
|
-
);
|
31206
|
-
}
|
31207
|
-
if (index4 < joins.length - 1) {
|
31208
|
-
joinsArray.push(sql` `);
|
31209
|
-
}
|
31210
|
-
}
|
31211
|
-
}
|
31212
|
-
const joinsSql = sql.join(joinsArray);
|
31268
|
+
const tableSql = this.buildFromTable(table4);
|
31269
|
+
const joinsSql = this.buildJoins(joins);
|
31213
31270
|
const whereSql = where ? sql` where ${where}` : void 0;
|
31214
31271
|
const havingSql = having ? sql` having ${having}` : void 0;
|
31215
31272
|
const groupByList = [];
|
@@ -31275,45 +31332,56 @@ var init_dialect2 = __esm({
|
|
31275
31332
|
const offsetSql = offset ? sql` offset ${offset}` : void 0;
|
31276
31333
|
return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
|
31277
31334
|
}
|
31278
|
-
buildInsertQuery({ table: table4, values, onConflict, returning, withList }) {
|
31335
|
+
buildInsertQuery({ table: table4, values: valuesOrSelect, onConflict, returning, withList, select }) {
|
31279
31336
|
const valuesSqlList = [];
|
31280
31337
|
const columns = table4[Table2.Symbol.Columns];
|
31281
31338
|
const colEntries = Object.entries(columns).filter(
|
31282
31339
|
([_2, col]) => !col.shouldDisableInsert()
|
31283
31340
|
);
|
31284
31341
|
const insertOrder = colEntries.map(([, column4]) => sql.identifier(this.casing.getColumnCasing(column4)));
|
31285
|
-
|
31286
|
-
const
|
31287
|
-
|
31288
|
-
|
31289
|
-
|
31290
|
-
|
31291
|
-
|
31292
|
-
|
31293
|
-
|
31294
|
-
|
31295
|
-
|
31296
|
-
|
31297
|
-
|
31298
|
-
|
31342
|
+
if (select) {
|
31343
|
+
const select2 = valuesOrSelect;
|
31344
|
+
if (is(select2, SQL)) {
|
31345
|
+
valuesSqlList.push(select2);
|
31346
|
+
} else {
|
31347
|
+
valuesSqlList.push(select2.getSQL());
|
31348
|
+
}
|
31349
|
+
} else {
|
31350
|
+
const values = valuesOrSelect;
|
31351
|
+
valuesSqlList.push(sql.raw("values "));
|
31352
|
+
for (const [valueIndex, value] of values.entries()) {
|
31353
|
+
const valueList = [];
|
31354
|
+
for (const [fieldName, col] of colEntries) {
|
31355
|
+
const colValue = value[fieldName];
|
31356
|
+
if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
|
31357
|
+
let defaultValue;
|
31358
|
+
if (col.default !== null && col.default !== void 0) {
|
31359
|
+
defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
|
31360
|
+
} else if (col.defaultFn !== void 0) {
|
31361
|
+
const defaultFnResult = col.defaultFn();
|
31362
|
+
defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
|
31363
|
+
} else if (!col.default && col.onUpdateFn !== void 0) {
|
31364
|
+
const onUpdateFnResult = col.onUpdateFn();
|
31365
|
+
defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
|
31366
|
+
} else {
|
31367
|
+
defaultValue = sql`null`;
|
31368
|
+
}
|
31369
|
+
valueList.push(defaultValue);
|
31299
31370
|
} else {
|
31300
|
-
|
31371
|
+
valueList.push(colValue);
|
31301
31372
|
}
|
31302
|
-
valueList.push(defaultValue);
|
31303
|
-
} else {
|
31304
|
-
valueList.push(colValue);
|
31305
31373
|
}
|
31306
|
-
|
31307
|
-
|
31308
|
-
|
31309
|
-
|
31374
|
+
valuesSqlList.push(valueList);
|
31375
|
+
if (valueIndex < values.length - 1) {
|
31376
|
+
valuesSqlList.push(sql`, `);
|
31377
|
+
}
|
31310
31378
|
}
|
31311
31379
|
}
|
31312
31380
|
const withSql = this.buildWithCTE(withList);
|
31313
31381
|
const valuesSql = sql.join(valuesSqlList);
|
31314
31382
|
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
|
31315
31383
|
const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
|
31316
|
-
return sql`${withSql}insert into ${table4} ${insertOrder}
|
31384
|
+
return sql`${withSql}insert into ${table4} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
|
31317
31385
|
}
|
31318
31386
|
sqlToQuery(sql2, invokeSource) {
|
31319
31387
|
return sql2.toQuery({
|
@@ -31542,8 +31610,8 @@ var init_dialect2 = __esm({
|
|
31542
31610
|
};
|
31543
31611
|
}
|
31544
31612
|
};
|
31545
|
-
__publicField(SQLiteDialect,
|
31546
|
-
SQLiteSyncDialect = class extends (
|
31613
|
+
__publicField(SQLiteDialect, _a198, "SQLiteDialect");
|
31614
|
+
SQLiteSyncDialect = class extends (_b143 = SQLiteDialect, _a199 = entityKind, _b143) {
|
31547
31615
|
migrate(migrations, session, config) {
|
31548
31616
|
const migrationsTable = config === void 0 ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
|
31549
31617
|
const migrationTableCreate = sql`
|
@@ -31577,8 +31645,8 @@ var init_dialect2 = __esm({
|
|
31577
31645
|
}
|
31578
31646
|
}
|
31579
31647
|
};
|
31580
|
-
__publicField(SQLiteSyncDialect,
|
31581
|
-
SQLiteAsyncDialect = class extends (
|
31648
|
+
__publicField(SQLiteSyncDialect, _a199, "SQLiteSyncDialect");
|
31649
|
+
SQLiteAsyncDialect = class extends (_b144 = SQLiteDialect, _a200 = entityKind, _b144) {
|
31582
31650
|
async migrate(migrations, session, config) {
|
31583
31651
|
const migrationsTable = config === void 0 ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
|
31584
31652
|
const migrationTableCreate = sql`
|
@@ -31607,7 +31675,7 @@ var init_dialect2 = __esm({
|
|
31607
31675
|
});
|
31608
31676
|
}
|
31609
31677
|
};
|
31610
|
-
__publicField(SQLiteAsyncDialect,
|
31678
|
+
__publicField(SQLiteAsyncDialect, _a200, "SQLiteAsyncDialect");
|
31611
31679
|
}
|
31612
31680
|
});
|
31613
31681
|
|
@@ -31629,7 +31697,7 @@ function createSetOperator2(type, isAll) {
|
|
31629
31697
|
return leftSelect.addSetOperators(setOperators);
|
31630
31698
|
};
|
31631
31699
|
}
|
31632
|
-
var
|
31700
|
+
var _a201, SQLiteSelectBuilder, _a202, _b145, SQLiteSelectQueryBuilderBase, _a203, _b146, SQLiteSelectBase, getSQLiteSetOperators, union2, unionAll2, intersect2, except2;
|
31633
31701
|
var init_select3 = __esm({
|
31634
31702
|
"../drizzle-orm/dist/sqlite-core/query-builders/select.js"() {
|
31635
31703
|
"use strict";
|
@@ -31643,7 +31711,7 @@ var init_select3 = __esm({
|
|
31643
31711
|
init_utils2();
|
31644
31712
|
init_view_common();
|
31645
31713
|
init_view_base2();
|
31646
|
-
|
31714
|
+
_a201 = entityKind;
|
31647
31715
|
SQLiteSelectBuilder = class {
|
31648
31716
|
constructor(config) {
|
31649
31717
|
__publicField(this, "fields");
|
@@ -31684,8 +31752,8 @@ var init_select3 = __esm({
|
|
31684
31752
|
});
|
31685
31753
|
}
|
31686
31754
|
};
|
31687
|
-
__publicField(SQLiteSelectBuilder,
|
31688
|
-
SQLiteSelectQueryBuilderBase = class extends (
|
31755
|
+
__publicField(SQLiteSelectBuilder, _a201, "SQLiteSelectBuilder");
|
31756
|
+
SQLiteSelectQueryBuilderBase = class extends (_b145 = TypedQueryBuilder, _a202 = entityKind, _b145) {
|
31689
31757
|
constructor({ table: table4, fields, isPartialSelect, session, dialect: dialect4, withList, distinct }) {
|
31690
31758
|
super();
|
31691
31759
|
__publicField(this, "_");
|
@@ -32190,8 +32258,8 @@ var init_select3 = __esm({
|
|
32190
32258
|
return this;
|
32191
32259
|
}
|
32192
32260
|
};
|
32193
|
-
__publicField(SQLiteSelectQueryBuilderBase,
|
32194
|
-
SQLiteSelectBase = class extends (
|
32261
|
+
__publicField(SQLiteSelectQueryBuilderBase, _a202, "SQLiteSelectQueryBuilder");
|
32262
|
+
SQLiteSelectBase = class extends (_b146 = SQLiteSelectQueryBuilderBase, _a203 = entityKind, _b146) {
|
32195
32263
|
constructor() {
|
32196
32264
|
super(...arguments);
|
32197
32265
|
__publicField(this, "run", (placeholderValues) => {
|
@@ -32229,7 +32297,7 @@ var init_select3 = __esm({
|
|
32229
32297
|
return this.all();
|
32230
32298
|
}
|
32231
32299
|
};
|
32232
|
-
__publicField(SQLiteSelectBase,
|
32300
|
+
__publicField(SQLiteSelectBase, _a203, "SQLiteSelect");
|
32233
32301
|
applyMixins(SQLiteSelectBase, [QueryPromise]);
|
32234
32302
|
getSQLiteSetOperators = () => ({
|
32235
32303
|
union: union2,
|
@@ -32245,7 +32313,7 @@ var init_select3 = __esm({
|
|
32245
32313
|
});
|
32246
32314
|
|
32247
32315
|
// ../drizzle-orm/dist/sqlite-core/query-builders/query-builder.js
|
32248
|
-
var
|
32316
|
+
var _a204, QueryBuilder2;
|
32249
32317
|
var init_query_builder3 = __esm({
|
32250
32318
|
"../drizzle-orm/dist/sqlite-core/query-builders/query-builder.js"() {
|
32251
32319
|
"use strict";
|
@@ -32254,7 +32322,7 @@ var init_query_builder3 = __esm({
|
|
32254
32322
|
init_dialect2();
|
32255
32323
|
init_subquery();
|
32256
32324
|
init_select3();
|
32257
|
-
|
32325
|
+
_a204 = entityKind;
|
32258
32326
|
QueryBuilder2 = class {
|
32259
32327
|
constructor(dialect4) {
|
32260
32328
|
__publicField(this, "dialect");
|
@@ -32316,7 +32384,185 @@ var init_query_builder3 = __esm({
|
|
32316
32384
|
return this.dialect;
|
32317
32385
|
}
|
32318
32386
|
};
|
32319
|
-
__publicField(QueryBuilder2,
|
32387
|
+
__publicField(QueryBuilder2, _a204, "SQLiteQueryBuilder");
|
32388
|
+
}
|
32389
|
+
});
|
32390
|
+
|
32391
|
+
// ../drizzle-orm/dist/sqlite-core/query-builders/insert.js
|
32392
|
+
var _a205, SQLiteInsertBuilder, _a206, _b147, SQLiteInsertBase;
|
32393
|
+
var init_insert2 = __esm({
|
32394
|
+
"../drizzle-orm/dist/sqlite-core/query-builders/insert.js"() {
|
32395
|
+
"use strict";
|
32396
|
+
init_entity();
|
32397
|
+
init_query_promise();
|
32398
|
+
init_sql();
|
32399
|
+
init_table3();
|
32400
|
+
init_table();
|
32401
|
+
init_utils2();
|
32402
|
+
init_query_builder3();
|
32403
|
+
_a205 = entityKind;
|
32404
|
+
SQLiteInsertBuilder = class {
|
32405
|
+
constructor(table4, session, dialect4, withList) {
|
32406
|
+
this.table = table4;
|
32407
|
+
this.session = session;
|
32408
|
+
this.dialect = dialect4;
|
32409
|
+
this.withList = withList;
|
32410
|
+
}
|
32411
|
+
values(values) {
|
32412
|
+
values = Array.isArray(values) ? values : [values];
|
32413
|
+
if (values.length === 0) {
|
32414
|
+
throw new Error("values() must be called with at least one value");
|
32415
|
+
}
|
32416
|
+
const mappedValues = values.map((entry) => {
|
32417
|
+
const result = {};
|
32418
|
+
const cols = this.table[Table2.Symbol.Columns];
|
32419
|
+
for (const colKey of Object.keys(entry)) {
|
32420
|
+
const colValue = entry[colKey];
|
32421
|
+
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
32422
|
+
}
|
32423
|
+
return result;
|
32424
|
+
});
|
32425
|
+
return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
|
32426
|
+
}
|
32427
|
+
select(selectQuery) {
|
32428
|
+
const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder2()) : selectQuery;
|
32429
|
+
if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
|
32430
|
+
throw new Error(
|
32431
|
+
"Insert select error: selected fields are not the same or are in a different order compared to the table definition"
|
32432
|
+
);
|
32433
|
+
}
|
32434
|
+
return new SQLiteInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
|
32435
|
+
}
|
32436
|
+
};
|
32437
|
+
__publicField(SQLiteInsertBuilder, _a205, "SQLiteInsertBuilder");
|
32438
|
+
SQLiteInsertBase = class extends (_b147 = QueryPromise, _a206 = entityKind, _b147) {
|
32439
|
+
constructor(table4, values, session, dialect4, withList, select) {
|
32440
|
+
super();
|
32441
|
+
/** @internal */
|
32442
|
+
__publicField(this, "config");
|
32443
|
+
__publicField(this, "run", (placeholderValues) => {
|
32444
|
+
return this._prepare().run(placeholderValues);
|
32445
|
+
});
|
32446
|
+
__publicField(this, "all", (placeholderValues) => {
|
32447
|
+
return this._prepare().all(placeholderValues);
|
32448
|
+
});
|
32449
|
+
__publicField(this, "get", (placeholderValues) => {
|
32450
|
+
return this._prepare().get(placeholderValues);
|
32451
|
+
});
|
32452
|
+
__publicField(this, "values", (placeholderValues) => {
|
32453
|
+
return this._prepare().values(placeholderValues);
|
32454
|
+
});
|
32455
|
+
this.session = session;
|
32456
|
+
this.dialect = dialect4;
|
32457
|
+
this.config = { table: table4, values, withList, select };
|
32458
|
+
}
|
32459
|
+
returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
|
32460
|
+
this.config.returning = orderSelectedFields(fields);
|
32461
|
+
return this;
|
32462
|
+
}
|
32463
|
+
/**
|
32464
|
+
* Adds an `on conflict do nothing` clause to the query.
|
32465
|
+
*
|
32466
|
+
* Calling this method simply avoids inserting a row as its alternative action.
|
32467
|
+
*
|
32468
|
+
* See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
|
32469
|
+
*
|
32470
|
+
* @param config The `target` and `where` clauses.
|
32471
|
+
*
|
32472
|
+
* @example
|
32473
|
+
* ```ts
|
32474
|
+
* // Insert one row and cancel the insert if there's a conflict
|
32475
|
+
* await db.insert(cars)
|
32476
|
+
* .values({ id: 1, brand: 'BMW' })
|
32477
|
+
* .onConflictDoNothing();
|
32478
|
+
*
|
32479
|
+
* // Explicitly specify conflict target
|
32480
|
+
* await db.insert(cars)
|
32481
|
+
* .values({ id: 1, brand: 'BMW' })
|
32482
|
+
* .onConflictDoNothing({ target: cars.id });
|
32483
|
+
* ```
|
32484
|
+
*/
|
32485
|
+
onConflictDoNothing(config = {}) {
|
32486
|
+
if (config.target === void 0) {
|
32487
|
+
this.config.onConflict = sql`do nothing`;
|
32488
|
+
} else {
|
32489
|
+
const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
|
32490
|
+
const whereSql = config.where ? sql` where ${config.where}` : sql``;
|
32491
|
+
this.config.onConflict = sql`${targetSql} do nothing${whereSql}`;
|
32492
|
+
}
|
32493
|
+
return this;
|
32494
|
+
}
|
32495
|
+
/**
|
32496
|
+
* Adds an `on conflict do update` clause to the query.
|
32497
|
+
*
|
32498
|
+
* Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
|
32499
|
+
*
|
32500
|
+
* See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
|
32501
|
+
*
|
32502
|
+
* @param config The `target`, `set` and `where` clauses.
|
32503
|
+
*
|
32504
|
+
* @example
|
32505
|
+
* ```ts
|
32506
|
+
* // Update the row if there's a conflict
|
32507
|
+
* await db.insert(cars)
|
32508
|
+
* .values({ id: 1, brand: 'BMW' })
|
32509
|
+
* .onConflictDoUpdate({
|
32510
|
+
* target: cars.id,
|
32511
|
+
* set: { brand: 'Porsche' }
|
32512
|
+
* });
|
32513
|
+
*
|
32514
|
+
* // Upsert with 'where' clause
|
32515
|
+
* await db.insert(cars)
|
32516
|
+
* .values({ id: 1, brand: 'BMW' })
|
32517
|
+
* .onConflictDoUpdate({
|
32518
|
+
* target: cars.id,
|
32519
|
+
* set: { brand: 'newBMW' },
|
32520
|
+
* where: sql`${cars.createdAt} > '2023-01-01'::date`,
|
32521
|
+
* });
|
32522
|
+
* ```
|
32523
|
+
*/
|
32524
|
+
onConflictDoUpdate(config) {
|
32525
|
+
if (config.where && (config.targetWhere || config.setWhere)) {
|
32526
|
+
throw new Error(
|
32527
|
+
'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
|
32528
|
+
);
|
32529
|
+
}
|
32530
|
+
const whereSql = config.where ? sql` where ${config.where}` : void 0;
|
32531
|
+
const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
|
32532
|
+
const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
|
32533
|
+
const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
|
32534
|
+
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
32535
|
+
this.config.onConflict = sql`${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
|
32536
|
+
return this;
|
32537
|
+
}
|
32538
|
+
/** @internal */
|
32539
|
+
getSQL() {
|
32540
|
+
return this.dialect.buildInsertQuery(this.config);
|
32541
|
+
}
|
32542
|
+
toSQL() {
|
32543
|
+
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
32544
|
+
return rest;
|
32545
|
+
}
|
32546
|
+
/** @internal */
|
32547
|
+
_prepare(isOneTimeQuery = true) {
|
32548
|
+
return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
|
32549
|
+
this.dialect.sqlToQuery(this.getSQL()),
|
32550
|
+
this.config.returning,
|
32551
|
+
this.config.returning ? "all" : "run",
|
32552
|
+
true
|
32553
|
+
);
|
32554
|
+
}
|
32555
|
+
prepare() {
|
32556
|
+
return this._prepare(false);
|
32557
|
+
}
|
32558
|
+
async execute() {
|
32559
|
+
return this.config.returning ? this.all() : this.run();
|
32560
|
+
}
|
32561
|
+
$dynamic() {
|
32562
|
+
return this;
|
32563
|
+
}
|
32564
|
+
};
|
32565
|
+
__publicField(SQLiteInsertBase, _a206, "SQLiteInsert");
|
32320
32566
|
}
|
32321
32567
|
});
|
32322
32568
|
|
@@ -32336,8 +32582,11 @@ var init_update2 = __esm({
|
|
32336
32582
|
init_query_promise();
|
32337
32583
|
init_selection_proxy();
|
32338
32584
|
init_table3();
|
32585
|
+
init_subquery();
|
32339
32586
|
init_table();
|
32340
32587
|
init_utils2();
|
32588
|
+
init_view_common();
|
32589
|
+
init_view_base2();
|
32341
32590
|
_a207 = entityKind;
|
32342
32591
|
SQLiteUpdateBuilder = class {
|
32343
32592
|
constructor(table4, session, dialect4, withList) {
|
@@ -32362,6 +32611,10 @@ var init_update2 = __esm({
|
|
32362
32611
|
super();
|
32363
32612
|
/** @internal */
|
32364
32613
|
__publicField(this, "config");
|
32614
|
+
__publicField(this, "leftJoin", this.createJoin("left"));
|
32615
|
+
__publicField(this, "rightJoin", this.createJoin("right"));
|
32616
|
+
__publicField(this, "innerJoin", this.createJoin("inner"));
|
32617
|
+
__publicField(this, "fullJoin", this.createJoin("full"));
|
32365
32618
|
__publicField(this, "run", (placeholderValues) => {
|
32366
32619
|
return this._prepare().run(placeholderValues);
|
32367
32620
|
});
|
@@ -32376,7 +32629,34 @@ var init_update2 = __esm({
|
|
32376
32629
|
});
|
32377
32630
|
this.session = session;
|
32378
32631
|
this.dialect = dialect4;
|
32379
|
-
this.config = { set, table: table4, withList };
|
32632
|
+
this.config = { set, table: table4, withList, joins: [] };
|
32633
|
+
}
|
32634
|
+
from(source) {
|
32635
|
+
this.config.from = source;
|
32636
|
+
return this;
|
32637
|
+
}
|
32638
|
+
createJoin(joinType) {
|
32639
|
+
return (table4, on) => {
|
32640
|
+
const tableName = getTableLikeName(table4);
|
32641
|
+
if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
|
32642
|
+
throw new Error(`Alias "${tableName}" is already used in this query`);
|
32643
|
+
}
|
32644
|
+
if (typeof on === "function") {
|
32645
|
+
const from = this.config.from ? is(table4, SQLiteTable) ? table4[Table2.Symbol.Columns] : is(table4, Subquery) ? table4._.selectedFields : is(table4, SQLiteViewBase) ? table4[ViewBaseConfig].selectedFields : void 0 : void 0;
|
32646
|
+
on = on(
|
32647
|
+
new Proxy(
|
32648
|
+
this.config.table[Table2.Symbol.Columns],
|
32649
|
+
new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
|
32650
|
+
),
|
32651
|
+
from && new Proxy(
|
32652
|
+
from,
|
32653
|
+
new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
|
32654
|
+
)
|
32655
|
+
);
|
32656
|
+
}
|
32657
|
+
this.config.joins.push({ on, table: table4, joinType, alias: tableName });
|
32658
|
+
return this;
|
32659
|
+
};
|
32380
32660
|
}
|
32381
32661
|
/**
|
32382
32662
|
* Adds a 'where' clause to the query.
|
@@ -35674,131 +35954,6 @@ var init_delete3 = __esm({
|
|
35674
35954
|
}
|
35675
35955
|
});
|
35676
35956
|
|
35677
|
-
// ../drizzle-orm/dist/mysql-core/query-builders/insert.js
|
35678
|
-
var _a299, MySqlInsertBuilder, _a300, _b222, MySqlInsertBase;
|
35679
|
-
var init_insert3 = __esm({
|
35680
|
-
"../drizzle-orm/dist/mysql-core/query-builders/insert.js"() {
|
35681
|
-
"use strict";
|
35682
|
-
init_entity();
|
35683
|
-
init_query_promise();
|
35684
|
-
init_sql();
|
35685
|
-
init_table();
|
35686
|
-
init_utils2();
|
35687
|
-
_a299 = entityKind;
|
35688
|
-
MySqlInsertBuilder = class {
|
35689
|
-
constructor(table4, session, dialect4) {
|
35690
|
-
__publicField(this, "shouldIgnore", false);
|
35691
|
-
this.table = table4;
|
35692
|
-
this.session = session;
|
35693
|
-
this.dialect = dialect4;
|
35694
|
-
}
|
35695
|
-
ignore() {
|
35696
|
-
this.shouldIgnore = true;
|
35697
|
-
return this;
|
35698
|
-
}
|
35699
|
-
values(values) {
|
35700
|
-
values = Array.isArray(values) ? values : [values];
|
35701
|
-
if (values.length === 0) {
|
35702
|
-
throw new Error("values() must be called with at least one value");
|
35703
|
-
}
|
35704
|
-
const mappedValues = values.map((entry) => {
|
35705
|
-
const result = {};
|
35706
|
-
const cols = this.table[Table2.Symbol.Columns];
|
35707
|
-
for (const colKey of Object.keys(entry)) {
|
35708
|
-
const colValue = entry[colKey];
|
35709
|
-
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
35710
|
-
}
|
35711
|
-
return result;
|
35712
|
-
});
|
35713
|
-
return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
|
35714
|
-
}
|
35715
|
-
};
|
35716
|
-
__publicField(MySqlInsertBuilder, _a299, "MySqlInsertBuilder");
|
35717
|
-
MySqlInsertBase = class extends (_b222 = QueryPromise, _a300 = entityKind, _b222) {
|
35718
|
-
constructor(table4, values, ignore, session, dialect4) {
|
35719
|
-
super();
|
35720
|
-
__publicField(this, "config");
|
35721
|
-
__publicField(this, "execute", (placeholderValues) => {
|
35722
|
-
return this.prepare().execute(placeholderValues);
|
35723
|
-
});
|
35724
|
-
__publicField(this, "createIterator", () => {
|
35725
|
-
const self2 = this;
|
35726
|
-
return async function* (placeholderValues) {
|
35727
|
-
yield* self2.prepare().iterator(placeholderValues);
|
35728
|
-
};
|
35729
|
-
});
|
35730
|
-
__publicField(this, "iterator", this.createIterator());
|
35731
|
-
this.session = session;
|
35732
|
-
this.dialect = dialect4;
|
35733
|
-
this.config = { table: table4, values, ignore };
|
35734
|
-
}
|
35735
|
-
/**
|
35736
|
-
* Adds an `on duplicate key update` clause to the query.
|
35737
|
-
*
|
35738
|
-
* Calling this method will update update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
|
35739
|
-
*
|
35740
|
-
* See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
|
35741
|
-
*
|
35742
|
-
* @param config The `set` clause
|
35743
|
-
*
|
35744
|
-
* @example
|
35745
|
-
* ```ts
|
35746
|
-
* await db.insert(cars)
|
35747
|
-
* .values({ id: 1, brand: 'BMW'})
|
35748
|
-
* .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
|
35749
|
-
* ```
|
35750
|
-
*
|
35751
|
-
* While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
|
35752
|
-
*
|
35753
|
-
* ```ts
|
35754
|
-
* import { sql } from 'drizzle-orm';
|
35755
|
-
*
|
35756
|
-
* await db.insert(cars)
|
35757
|
-
* .values({ id: 1, brand: 'BMW' })
|
35758
|
-
* .onDuplicateKeyUpdate({ set: { id: sql`id` } });
|
35759
|
-
* ```
|
35760
|
-
*/
|
35761
|
-
onDuplicateKeyUpdate(config) {
|
35762
|
-
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
35763
|
-
this.config.onConflict = sql`update ${setSql}`;
|
35764
|
-
return this;
|
35765
|
-
}
|
35766
|
-
$returningId() {
|
35767
|
-
const returning = [];
|
35768
|
-
for (const [key, value] of Object.entries(this.config.table[Table2.Symbol.Columns])) {
|
35769
|
-
if (value.primary) {
|
35770
|
-
returning.push({ field: value, path: [key] });
|
35771
|
-
}
|
35772
|
-
}
|
35773
|
-
this.config.returning = orderSelectedFields(this.config.table[Table2.Symbol.Columns]);
|
35774
|
-
return this;
|
35775
|
-
}
|
35776
|
-
/** @internal */
|
35777
|
-
getSQL() {
|
35778
|
-
return this.dialect.buildInsertQuery(this.config).sql;
|
35779
|
-
}
|
35780
|
-
toSQL() {
|
35781
|
-
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
35782
|
-
return rest;
|
35783
|
-
}
|
35784
|
-
prepare() {
|
35785
|
-
const { sql: sql2, generatedIds } = this.dialect.buildInsertQuery(this.config);
|
35786
|
-
return this.session.prepareQuery(
|
35787
|
-
this.dialect.sqlToQuery(sql2),
|
35788
|
-
void 0,
|
35789
|
-
void 0,
|
35790
|
-
generatedIds,
|
35791
|
-
this.config.returning
|
35792
|
-
);
|
35793
|
-
}
|
35794
|
-
$dynamic() {
|
35795
|
-
return this;
|
35796
|
-
}
|
35797
|
-
};
|
35798
|
-
__publicField(MySqlInsertBase, _a300, "MySqlInsert");
|
35799
|
-
}
|
35800
|
-
});
|
35801
|
-
|
35802
35957
|
// ../drizzle-orm/dist/mysql-core/columns/all.js
|
35803
35958
|
function getMySqlColumnBuilders() {
|
35804
35959
|
return {
|
@@ -35879,7 +36034,7 @@ function mysqlTableWithSchema(name2, columns, extraConfig, schema4, baseName = n
|
|
35879
36034
|
}
|
35880
36035
|
return table4;
|
35881
36036
|
}
|
35882
|
-
var InlineForeignKeys3,
|
36037
|
+
var InlineForeignKeys3, _a299, _b222, _c9, _d4, _e4, MySqlTable, mysqlTable;
|
35883
36038
|
var init_table4 = __esm({
|
35884
36039
|
"../drizzle-orm/dist/mysql-core/table.js"() {
|
35885
36040
|
"use strict";
|
@@ -35887,15 +36042,15 @@ var init_table4 = __esm({
|
|
35887
36042
|
init_table();
|
35888
36043
|
init_all3();
|
35889
36044
|
InlineForeignKeys3 = Symbol.for("drizzle:MySqlInlineForeignKeys");
|
35890
|
-
MySqlTable = class extends (_e4 = Table2, _d4 = entityKind, _c9 = Table2.Symbol.Columns,
|
36045
|
+
MySqlTable = class extends (_e4 = Table2, _d4 = entityKind, _c9 = Table2.Symbol.Columns, _b222 = InlineForeignKeys3, _a299 = Table2.Symbol.ExtraConfigBuilder, _e4) {
|
35891
36046
|
constructor() {
|
35892
36047
|
super(...arguments);
|
35893
36048
|
/** @internal */
|
35894
36049
|
__publicField(this, _c9);
|
35895
36050
|
/** @internal */
|
35896
|
-
__publicField(this,
|
36051
|
+
__publicField(this, _b222, []);
|
35897
36052
|
/** @internal */
|
35898
|
-
__publicField(this,
|
36053
|
+
__publicField(this, _a299);
|
35899
36054
|
}
|
35900
36055
|
};
|
35901
36056
|
__publicField(MySqlTable, _d4, "MySqlTable");
|
@@ -35910,20 +36065,20 @@ var init_table4 = __esm({
|
|
35910
36065
|
});
|
35911
36066
|
|
35912
36067
|
// ../drizzle-orm/dist/mysql-core/view-base.js
|
35913
|
-
var
|
36068
|
+
var _a300, _b223, MySqlViewBase;
|
35914
36069
|
var init_view_base3 = __esm({
|
35915
36070
|
"../drizzle-orm/dist/mysql-core/view-base.js"() {
|
35916
36071
|
"use strict";
|
35917
36072
|
init_entity();
|
35918
36073
|
init_sql();
|
35919
|
-
MySqlViewBase = class extends (
|
36074
|
+
MySqlViewBase = class extends (_b223 = View3, _a300 = entityKind, _b223) {
|
35920
36075
|
};
|
35921
|
-
__publicField(MySqlViewBase,
|
36076
|
+
__publicField(MySqlViewBase, _a300, "MySqlViewBase");
|
35922
36077
|
}
|
35923
36078
|
});
|
35924
36079
|
|
35925
36080
|
// ../drizzle-orm/dist/mysql-core/dialect.js
|
35926
|
-
var
|
36081
|
+
var _a301, MySqlDialect;
|
35927
36082
|
var init_dialect3 = __esm({
|
35928
36083
|
"../drizzle-orm/dist/mysql-core/dialect.js"() {
|
35929
36084
|
"use strict";
|
@@ -35942,7 +36097,7 @@ var init_dialect3 = __esm({
|
|
35942
36097
|
init_common4();
|
35943
36098
|
init_table4();
|
35944
36099
|
init_view_base3();
|
35945
|
-
|
36100
|
+
_a301 = entityKind;
|
35946
36101
|
MySqlDialect = class {
|
35947
36102
|
constructor(config) {
|
35948
36103
|
/** @internal */
|
@@ -36225,7 +36380,7 @@ var init_dialect3 = __esm({
|
|
36225
36380
|
const offsetSql = offset ? sql` offset ${offset}` : void 0;
|
36226
36381
|
return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
|
36227
36382
|
}
|
36228
|
-
buildInsertQuery({ table: table4, values, ignore, onConflict }) {
|
36383
|
+
buildInsertQuery({ table: table4, values: valuesOrSelect, ignore, onConflict, select }) {
|
36229
36384
|
const valuesSqlList = [];
|
36230
36385
|
const columns = table4[Table2.Symbol.Columns];
|
36231
36386
|
const colEntries = Object.entries(columns).filter(
|
@@ -36233,42 +36388,53 @@ var init_dialect3 = __esm({
|
|
36233
36388
|
);
|
36234
36389
|
const insertOrder = colEntries.map(([, column4]) => sql.identifier(this.casing.getColumnCasing(column4)));
|
36235
36390
|
const generatedIdsResponse = [];
|
36236
|
-
|
36237
|
-
const
|
36238
|
-
|
36239
|
-
|
36240
|
-
|
36241
|
-
|
36242
|
-
|
36243
|
-
|
36244
|
-
|
36245
|
-
|
36246
|
-
|
36247
|
-
|
36248
|
-
|
36249
|
-
|
36250
|
-
|
36391
|
+
if (select) {
|
36392
|
+
const select2 = valuesOrSelect;
|
36393
|
+
if (is(select2, SQL)) {
|
36394
|
+
valuesSqlList.push(select2);
|
36395
|
+
} else {
|
36396
|
+
valuesSqlList.push(select2.getSQL());
|
36397
|
+
}
|
36398
|
+
} else {
|
36399
|
+
const values = valuesOrSelect;
|
36400
|
+
valuesSqlList.push(sql.raw("values "));
|
36401
|
+
for (const [valueIndex, value] of values.entries()) {
|
36402
|
+
const generatedIds = {};
|
36403
|
+
const valueList = [];
|
36404
|
+
for (const [fieldName, col] of colEntries) {
|
36405
|
+
const colValue = value[fieldName];
|
36406
|
+
if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
|
36407
|
+
if (col.defaultFn !== void 0) {
|
36408
|
+
const defaultFnResult = col.defaultFn();
|
36409
|
+
generatedIds[fieldName] = defaultFnResult;
|
36410
|
+
const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
|
36411
|
+
valueList.push(defaultValue);
|
36412
|
+
} else if (!col.default && col.onUpdateFn !== void 0) {
|
36413
|
+
const onUpdateFnResult = col.onUpdateFn();
|
36414
|
+
const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
|
36415
|
+
valueList.push(newValue);
|
36416
|
+
} else {
|
36417
|
+
valueList.push(sql`default`);
|
36418
|
+
}
|
36251
36419
|
} else {
|
36252
|
-
|
36253
|
-
|
36254
|
-
|
36255
|
-
|
36256
|
-
generatedIds[fieldName] = colValue.value;
|
36420
|
+
if (col.defaultFn && is(colValue, Param)) {
|
36421
|
+
generatedIds[fieldName] = colValue.value;
|
36422
|
+
}
|
36423
|
+
valueList.push(colValue);
|
36257
36424
|
}
|
36258
|
-
valueList.push(colValue);
|
36259
36425
|
}
|
36260
|
-
|
36261
|
-
|
36262
|
-
|
36263
|
-
|
36264
|
-
|
36426
|
+
generatedIdsResponse.push(generatedIds);
|
36427
|
+
valuesSqlList.push(valueList);
|
36428
|
+
if (valueIndex < values.length - 1) {
|
36429
|
+
valuesSqlList.push(sql`, `);
|
36430
|
+
}
|
36265
36431
|
}
|
36266
36432
|
}
|
36267
36433
|
const valuesSql = sql.join(valuesSqlList);
|
36268
36434
|
const ignoreSql = ignore ? sql` ignore` : void 0;
|
36269
36435
|
const onConflictSql = onConflict ? sql` on duplicate key ${onConflict}` : void 0;
|
36270
36436
|
return {
|
36271
|
-
sql: sql`insert${ignoreSql} into ${table4} ${insertOrder}
|
36437
|
+
sql: sql`insert${ignoreSql} into ${table4} ${insertOrder} ${valuesSql}${onConflictSql}`,
|
36272
36438
|
generatedIds: generatedIdsResponse
|
36273
36439
|
};
|
36274
36440
|
}
|
@@ -36728,7 +36894,7 @@ var init_dialect3 = __esm({
|
|
36728
36894
|
};
|
36729
36895
|
}
|
36730
36896
|
};
|
36731
|
-
__publicField(MySqlDialect,
|
36897
|
+
__publicField(MySqlDialect, _a301, "MySqlDialect");
|
36732
36898
|
}
|
36733
36899
|
});
|
36734
36900
|
|
@@ -36750,7 +36916,7 @@ function createSetOperator3(type, isAll) {
|
|
36750
36916
|
return leftSelect.addSetOperators(setOperators);
|
36751
36917
|
};
|
36752
36918
|
}
|
36753
|
-
var
|
36919
|
+
var _a302, MySqlSelectBuilder, _a303, _b224, MySqlSelectQueryBuilderBase, _a304, _b225, MySqlSelectBase, getMySqlSetOperators, union3, unionAll3, intersect3, intersectAll2, except3, exceptAll2;
|
36754
36920
|
var init_select4 = __esm({
|
36755
36921
|
"../drizzle-orm/dist/mysql-core/query-builders/select.js"() {
|
36756
36922
|
"use strict";
|
@@ -36765,7 +36931,7 @@ var init_select4 = __esm({
|
|
36765
36931
|
init_utils2();
|
36766
36932
|
init_view_common();
|
36767
36933
|
init_view_base3();
|
36768
|
-
|
36934
|
+
_a302 = entityKind;
|
36769
36935
|
MySqlSelectBuilder = class {
|
36770
36936
|
constructor(config) {
|
36771
36937
|
__publicField(this, "fields");
|
@@ -36810,8 +36976,8 @@ var init_select4 = __esm({
|
|
36810
36976
|
);
|
36811
36977
|
}
|
36812
36978
|
};
|
36813
|
-
__publicField(MySqlSelectBuilder,
|
36814
|
-
MySqlSelectQueryBuilderBase = class extends (
|
36979
|
+
__publicField(MySqlSelectBuilder, _a302, "MySqlSelectBuilder");
|
36980
|
+
MySqlSelectQueryBuilderBase = class extends (_b224 = TypedQueryBuilder, _a303 = entityKind, _b224) {
|
36815
36981
|
constructor({ table: table4, fields, isPartialSelect, session, dialect: dialect4, withList, distinct }) {
|
36816
36982
|
super();
|
36817
36983
|
__publicField(this, "_");
|
@@ -37412,8 +37578,8 @@ var init_select4 = __esm({
|
|
37412
37578
|
return this;
|
37413
37579
|
}
|
37414
37580
|
};
|
37415
|
-
__publicField(MySqlSelectQueryBuilderBase,
|
37416
|
-
MySqlSelectBase = class extends (
|
37581
|
+
__publicField(MySqlSelectQueryBuilderBase, _a303, "MySqlSelectQueryBuilder");
|
37582
|
+
MySqlSelectBase = class extends (_b225 = MySqlSelectQueryBuilderBase, _a304 = entityKind, _b225) {
|
37417
37583
|
constructor() {
|
37418
37584
|
super(...arguments);
|
37419
37585
|
__publicField(this, "execute", (placeholderValues) => {
|
@@ -37437,7 +37603,7 @@ var init_select4 = __esm({
|
|
37437
37603
|
return query;
|
37438
37604
|
}
|
37439
37605
|
};
|
37440
|
-
__publicField(MySqlSelectBase,
|
37606
|
+
__publicField(MySqlSelectBase, _a304, "MySqlSelect");
|
37441
37607
|
applyMixins(MySqlSelectBase, [QueryPromise]);
|
37442
37608
|
getMySqlSetOperators = () => ({
|
37443
37609
|
union: union3,
|
@@ -37457,7 +37623,7 @@ var init_select4 = __esm({
|
|
37457
37623
|
});
|
37458
37624
|
|
37459
37625
|
// ../drizzle-orm/dist/mysql-core/query-builders/query-builder.js
|
37460
|
-
var
|
37626
|
+
var _a305, QueryBuilder3;
|
37461
37627
|
var init_query_builder4 = __esm({
|
37462
37628
|
"../drizzle-orm/dist/mysql-core/query-builders/query-builder.js"() {
|
37463
37629
|
"use strict";
|
@@ -37466,7 +37632,7 @@ var init_query_builder4 = __esm({
|
|
37466
37632
|
init_selection_proxy();
|
37467
37633
|
init_subquery();
|
37468
37634
|
init_select4();
|
37469
|
-
|
37635
|
+
_a305 = entityKind;
|
37470
37636
|
QueryBuilder3 = class {
|
37471
37637
|
constructor(dialect4) {
|
37472
37638
|
__publicField(this, "dialect");
|
@@ -37528,7 +37694,142 @@ var init_query_builder4 = __esm({
|
|
37528
37694
|
return this.dialect;
|
37529
37695
|
}
|
37530
37696
|
};
|
37531
|
-
__publicField(QueryBuilder3,
|
37697
|
+
__publicField(QueryBuilder3, _a305, "MySqlQueryBuilder");
|
37698
|
+
}
|
37699
|
+
});
|
37700
|
+
|
37701
|
+
// ../drizzle-orm/dist/mysql-core/query-builders/insert.js
|
37702
|
+
var _a306, MySqlInsertBuilder, _a307, _b226, MySqlInsertBase;
|
37703
|
+
var init_insert3 = __esm({
|
37704
|
+
"../drizzle-orm/dist/mysql-core/query-builders/insert.js"() {
|
37705
|
+
"use strict";
|
37706
|
+
init_entity();
|
37707
|
+
init_query_promise();
|
37708
|
+
init_sql();
|
37709
|
+
init_table();
|
37710
|
+
init_utils2();
|
37711
|
+
init_query_builder4();
|
37712
|
+
_a306 = entityKind;
|
37713
|
+
MySqlInsertBuilder = class {
|
37714
|
+
constructor(table4, session, dialect4) {
|
37715
|
+
__publicField(this, "shouldIgnore", false);
|
37716
|
+
this.table = table4;
|
37717
|
+
this.session = session;
|
37718
|
+
this.dialect = dialect4;
|
37719
|
+
}
|
37720
|
+
ignore() {
|
37721
|
+
this.shouldIgnore = true;
|
37722
|
+
return this;
|
37723
|
+
}
|
37724
|
+
values(values) {
|
37725
|
+
values = Array.isArray(values) ? values : [values];
|
37726
|
+
if (values.length === 0) {
|
37727
|
+
throw new Error("values() must be called with at least one value");
|
37728
|
+
}
|
37729
|
+
const mappedValues = values.map((entry) => {
|
37730
|
+
const result = {};
|
37731
|
+
const cols = this.table[Table2.Symbol.Columns];
|
37732
|
+
for (const colKey of Object.keys(entry)) {
|
37733
|
+
const colValue = entry[colKey];
|
37734
|
+
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
37735
|
+
}
|
37736
|
+
return result;
|
37737
|
+
});
|
37738
|
+
return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
|
37739
|
+
}
|
37740
|
+
select(selectQuery) {
|
37741
|
+
const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder3()) : selectQuery;
|
37742
|
+
if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
|
37743
|
+
throw new Error(
|
37744
|
+
"Insert select error: selected fields are not the same or are in a different order compared to the table definition"
|
37745
|
+
);
|
37746
|
+
}
|
37747
|
+
return new MySqlInsertBase(this.table, select, this.shouldIgnore, this.session, this.dialect, true);
|
37748
|
+
}
|
37749
|
+
};
|
37750
|
+
__publicField(MySqlInsertBuilder, _a306, "MySqlInsertBuilder");
|
37751
|
+
MySqlInsertBase = class extends (_b226 = QueryPromise, _a307 = entityKind, _b226) {
|
37752
|
+
constructor(table4, values, ignore, session, dialect4, select) {
|
37753
|
+
super();
|
37754
|
+
__publicField(this, "config");
|
37755
|
+
__publicField(this, "execute", (placeholderValues) => {
|
37756
|
+
return this.prepare().execute(placeholderValues);
|
37757
|
+
});
|
37758
|
+
__publicField(this, "createIterator", () => {
|
37759
|
+
const self2 = this;
|
37760
|
+
return async function* (placeholderValues) {
|
37761
|
+
yield* self2.prepare().iterator(placeholderValues);
|
37762
|
+
};
|
37763
|
+
});
|
37764
|
+
__publicField(this, "iterator", this.createIterator());
|
37765
|
+
this.session = session;
|
37766
|
+
this.dialect = dialect4;
|
37767
|
+
this.config = { table: table4, values, select, ignore };
|
37768
|
+
}
|
37769
|
+
/**
|
37770
|
+
* Adds an `on duplicate key update` clause to the query.
|
37771
|
+
*
|
37772
|
+
* Calling this method will update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
|
37773
|
+
*
|
37774
|
+
* See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
|
37775
|
+
*
|
37776
|
+
* @param config The `set` clause
|
37777
|
+
*
|
37778
|
+
* @example
|
37779
|
+
* ```ts
|
37780
|
+
* await db.insert(cars)
|
37781
|
+
* .values({ id: 1, brand: 'BMW'})
|
37782
|
+
* .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
|
37783
|
+
* ```
|
37784
|
+
*
|
37785
|
+
* While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
|
37786
|
+
*
|
37787
|
+
* ```ts
|
37788
|
+
* import { sql } from 'drizzle-orm';
|
37789
|
+
*
|
37790
|
+
* await db.insert(cars)
|
37791
|
+
* .values({ id: 1, brand: 'BMW' })
|
37792
|
+
* .onDuplicateKeyUpdate({ set: { id: sql`id` } });
|
37793
|
+
* ```
|
37794
|
+
*/
|
37795
|
+
onDuplicateKeyUpdate(config) {
|
37796
|
+
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
37797
|
+
this.config.onConflict = sql`update ${setSql}`;
|
37798
|
+
return this;
|
37799
|
+
}
|
37800
|
+
$returningId() {
|
37801
|
+
const returning = [];
|
37802
|
+
for (const [key, value] of Object.entries(this.config.table[Table2.Symbol.Columns])) {
|
37803
|
+
if (value.primary) {
|
37804
|
+
returning.push({ field: value, path: [key] });
|
37805
|
+
}
|
37806
|
+
}
|
37807
|
+
this.config.returning = returning;
|
37808
|
+
return this;
|
37809
|
+
}
|
37810
|
+
/** @internal */
|
37811
|
+
getSQL() {
|
37812
|
+
return this.dialect.buildInsertQuery(this.config).sql;
|
37813
|
+
}
|
37814
|
+
toSQL() {
|
37815
|
+
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
37816
|
+
return rest;
|
37817
|
+
}
|
37818
|
+
prepare() {
|
37819
|
+
const { sql: sql2, generatedIds } = this.dialect.buildInsertQuery(this.config);
|
37820
|
+
return this.session.prepareQuery(
|
37821
|
+
this.dialect.sqlToQuery(sql2),
|
37822
|
+
void 0,
|
37823
|
+
void 0,
|
37824
|
+
generatedIds,
|
37825
|
+
this.config.returning
|
37826
|
+
);
|
37827
|
+
}
|
37828
|
+
$dynamic() {
|
37829
|
+
return this;
|
37830
|
+
}
|
37831
|
+
};
|
37832
|
+
__publicField(MySqlInsertBase, _a307, "MySqlInsert");
|
37532
37833
|
}
|
37533
37834
|
});
|
37534
37835
|
|