typeorm
Version:
Data-Mapper ORM for TypeScript and ES2023+. Supports MySQL/MariaDB, PostgreSQL, MS SQL Server, Oracle, SAP HANA, SQLite, MongoDB databases.
1,209 lines • 59.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InsertQueryBuilder = void 0;
const DriverUtils_1 = require("../driver/DriverUtils");
const error_1 = require("../error");
const InsertValuesMissingError_1 = require("../error/InsertValuesMissingError");
const ReturningStatementNotSupportedError_1 = require("../error/ReturningStatementNotSupportedError");
const BroadcasterResult_1 = require("../subscriber/BroadcasterResult");
const InstanceChecker_1 = require("../util/InstanceChecker");
const ObjectUtils_1 = require("../util/ObjectUtils");
const RandomGenerator_1 = require("../util/RandomGenerator");
const QueryBuilder_1 = require("./QueryBuilder");
const InsertResult_1 = require("./result/InsertResult");
const ReturningResultsEntityUpdator_1 = require("./ReturningResultsEntityUpdator");
/**
* Allows to build complex sql queries in a fashion way and execute those queries.
*/
class InsertQueryBuilder extends QueryBuilder_1.QueryBuilder {
constructor() {
super(...arguments);
this["@instanceof"] = Symbol.for("InsertQueryBuilder");
}
// -------------------------------------------------------------------------
// Public Implemented Methods
// -------------------------------------------------------------------------
/**
* Gets generated SQL query without parameters being replaced.
*/
getQuery() {
let sql = this.createComment();
sql += this.createCteExpression();
sql += this.createInsertExpression();
return this.replacePropertyNamesForTheWholeQuery(sql.trim());
}
/**
* Executes sql generated by query builder and returns raw database results.
*/
async execute() {
// console.timeEnd(".value sets");
const valueSets = this.getValueSets();
// If user passed empty array of entities then we don't need to do
// anything.
//
// Fixes GitHub issues #3111 and #5734. If we were to let this through
// we would run into problems downstream, like subscribers getting
// invoked with the empty array where they expect an entity, and SQL
// queries with an empty VALUES clause.
if (valueSets.length === 0 && !this.expressionMap.insertFromSelect)
return new InsertResult_1.InsertResult();
// console.time("QueryBuilder.execute");
// console.time(".database stuff");
const queryRunner = this.obtainQueryRunner();
let transactionStartedByUs = false;
try {
// start transaction if it was enabled
if (this.expressionMap.useTransaction === true &&
queryRunner.isTransactionActive === false) {
await queryRunner.startTransaction();
transactionStartedByUs = true;
}
// console.timeEnd(".database stuff");
// call before insertion methods in listeners and subscribers
// Skip for INSERT FROM SELECT as there are no individual value sets
if (!this.expressionMap.insertFromSelect &&
this.expressionMap.callListeners === true &&
this.expressionMap.mainAlias.hasMetadata) {
const broadcastResult = new BroadcasterResult_1.BroadcasterResult();
valueSets.forEach((valueSet) => {
queryRunner.broadcaster.broadcastBeforeInsertEvent(broadcastResult, this.expressionMap.mainAlias.metadata, valueSet);
});
await broadcastResult.wait();
}
let declareSql = null;
let selectOutputSql = null;
// if update entity mode is enabled we may need extra columns for the returning statement
// console.time(".prepare returning statement");
const returningResultsEntityUpdator = new ReturningResultsEntityUpdator_1.ReturningResultsEntityUpdator(queryRunner, this.expressionMap);
const returningColumns = [];
if (Array.isArray(this.expressionMap.returning) &&
this.expressionMap.mainAlias.hasMetadata) {
for (const columnPath of this.expressionMap.returning) {
returningColumns.push(...this.expressionMap.mainAlias.metadata.findColumnsWithPropertyPath(columnPath));
}
}
if (this.expressionMap.updateEntity === true &&
this.expressionMap.mainAlias.hasMetadata) {
if (!(valueSets.length > 1 &&
this.dataSource.driver.options.type === "oracle")) {
this.expressionMap.extraReturningColumns =
this.expressionMap.mainAlias.metadata.getInsertionReturningColumns();
}
returningColumns.push(...this.expressionMap.extraReturningColumns.filter((c) => !returningColumns.includes(c)));
}
if (returningColumns.length > 0 &&
this.dataSource.driver.options.type === "mssql") {
declareSql = this.dataSource.driver.buildTableVariableDeclaration("@OutputTable", returningColumns);
selectOutputSql = `SELECT * FROM @OutputTable`;
}
// console.timeEnd(".prepare returning statement");
// execute query
// console.time(".getting query and parameters");
const [insertSql, parameters] = this.getQueryAndParameters();
// console.timeEnd(".getting query and parameters");
// console.time(".query execution by database");
const statements = [declareSql, insertSql, selectOutputSql];
const sql = statements.filter((s) => s != null).join(";\n\n");
const queryResult = await queryRunner.query(sql, parameters, true);
const insertResult = InsertResult_1.InsertResult.from(queryResult);
// console.timeEnd(".query execution by database");
// load returning results and set them to the entity if entity updation is enabled
// Skip for INSERT FROM SELECT as there are no entities to update
if (!this.expressionMap.insertFromSelect &&
this.expressionMap.updateEntity === true &&
this.expressionMap.mainAlias.hasMetadata) {
// console.time(".updating entity");
await returningResultsEntityUpdator.insert(insertResult, valueSets);
// console.timeEnd(".updating entity");
}
// call after insertion methods in listeners and subscribers
// Skip for INSERT FROM SELECT as there are no individual value sets
if (!this.expressionMap.insertFromSelect &&
this.expressionMap.callListeners === true &&
this.expressionMap.mainAlias.hasMetadata) {
const broadcastResult = new BroadcasterResult_1.BroadcasterResult();
valueSets.forEach((valueSet) => {
queryRunner.broadcaster.broadcastAfterInsertEvent(broadcastResult, this.expressionMap.mainAlias.metadata, valueSet);
});
await broadcastResult.wait();
}
// close transaction if we started it
// console.time(".commit");
if (transactionStartedByUs) {
await queryRunner.commitTransaction();
}
// console.timeEnd(".commit");
return insertResult;
}
catch (error) {
// rollback transaction if we started it
if (transactionStartedByUs) {
try {
await queryRunner.rollbackTransaction();
}
catch (rollbackError) { }
}
throw error;
}
finally {
// console.time(".releasing connection");
if (queryRunner !== this.queryRunner) {
// means we created our own query runner
await queryRunner.release();
}
// console.timeEnd(".releasing connection");
// console.timeEnd("QueryBuilder.execute");
}
}
// -------------------------------------------------------------------------
// Public Methods
// -------------------------------------------------------------------------
/**
* Specifies INTO which entity's table insertion will be executed.
*
* @param entityTarget
* @param columns
*/
into(entityTarget, columns) {
entityTarget = InstanceChecker_1.InstanceChecker.isEntitySchema(entityTarget)
? entityTarget.options.name
: entityTarget;
const mainAlias = this.createFromAlias(entityTarget);
this.expressionMap.setMainAlias(mainAlias);
this.expressionMap.insertColumns = columns ?? [];
return this;
}
/**
* Values needs to be inserted into table.
*
* @param values
*/
values(values) {
this.expressionMap.valuesSet = values;
return this;
}
/**
* Specifies a SELECT query to use as the source of values for the INSERT.
* This creates an INSERT INTO ... SELECT FROM statement.
*
* @param queryBuilderOrFactory
*/
valuesFromSelect(queryBuilderOrFactory) {
let selectQueryBuilder;
if (typeof queryBuilderOrFactory === "function") {
const subQuery = this.createQueryBuilder().select();
selectQueryBuilder = queryBuilderOrFactory(subQuery);
}
else {
selectQueryBuilder = queryBuilderOrFactory;
}
this.setParameters(selectQueryBuilder.getParameters());
this.expressionMap.insertFromSelect = selectQueryBuilder;
return this;
}
/**
* Optional returning/output clause.
*
* @param output
*/
output(output) {
return this.returning(output);
}
/**
* Optional returning/output clause.
*
* @param returning
*/
returning(returning) {
// not all databases support returning/output cause
if (!this.dataSource.driver.isReturningSqlSupported("insert")) {
throw new ReturningStatementNotSupportedError_1.ReturningStatementNotSupportedError();
}
this.expressionMap.returning = returning;
return this;
}
/**
* Indicates if entity must be updated after insertion operations.
* This may produce extra query or use RETURNING / OUTPUT statement (depend on database).
* Enabled by default.
*
* @param enabled
*/
updateEntity(enabled) {
this.expressionMap.updateEntity = enabled;
return this;
}
/**
* Adds additional ignore statement supported in databases.
*
* @param statement
*/
orIgnore(statement = true) {
this.expressionMap.onIgnore = !!statement;
return this;
}
/**
* Adds an "upsert" clause to the insert query — when a row with the same
* conflict target already exists the listed columns are updated instead.
*
* @param overwrite - Column names to overwrite on conflict.
* @param conflictTarget - Column name(s) or constraint name used to detect
* conflicts. When an array is given the columns form a composite key;
* when a string is given it is treated as a constraint name.
* @param orUpdateOptions - Additional options such as `skipUpdateIfNoValuesChanged`,
* `indexPredicate`, `upsertType`, or `overwriteCondition`.
*/
orUpdate(overwrite, conflictTarget, orUpdateOptions) {
const { where, parameters } = orUpdateOptions?.overwriteCondition ?? {};
let wheres;
if (where) {
const condition = this.getWhereCondition(where);
if (Array.isArray(condition) ? condition.length !== 0 : condition)
wheres = [{ type: "simple", condition: condition }];
}
if (parameters)
this.setParameters(parameters);
this.expressionMap.onUpdate = {
overwrite: overwrite,
conflict: conflictTarget,
skipUpdateIfNoValuesChanged: orUpdateOptions?.skipUpdateIfNoValuesChanged,
indexPredicate: orUpdateOptions?.indexPredicate,
upsertType: orUpdateOptions?.upsertType,
overwriteCondition: wheres,
};
return this;
}
// -------------------------------------------------------------------------
// Protected Methods
// -------------------------------------------------------------------------
/**
* Creates INSERT express used to perform insert query.
*/
createInsertExpression() {
if (this.expressionMap.onUpdate || this.expressionMap.onIgnore) {
if ((this.expressionMap.onUpdate?.upsertType ?? "merge-into") ===
"merge-into" &&
this.dataSource.driver.supportedUpsertTypes.includes("merge-into"))
return this.createMergeExpression();
}
const tableName = this.getTableName(this.getMainTableName());
const tableOrAliasName = this.alias !== this.getMainTableName()
? this.escape(this.alias)
: tableName;
const valuesExpression = this.createValuesExpression(); // its important to get values before returning expression because oracle rely on native parameters and ordering of them is important
const returningExpression = this.dataSource.driver.options.type === "oracle" &&
this.getValueSets().length > 1
? null
: this.createReturningExpression("insert"); // oracle doesnt support returning with multi-row insert
const columnsExpression = this.createColumnNamesExpression();
let query = "INSERT ";
if (this.expressionMap.onUpdate?.upsertType === "primary-key") {
query = "UPSERT ";
}
if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "aurora-mysql") {
query += `${this.expressionMap.onIgnore ? " IGNORE " : ""}`;
}
query += `INTO ${tableName}`;
if (this.alias !== this.getMainTableName() &&
DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver)) {
query += ` AS "${this.alias}"`;
}
// add columns expression
if (columnsExpression) {
query += `(${columnsExpression})`;
}
else {
if (!valuesExpression &&
(DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "aurora-mysql"))
// special syntax for mysql DEFAULT VALUES insertion
query += "()";
}
if (this.expressionMap.insertFromSelect)
query += ` ${this.expressionMap.insertFromSelect.getQuery()}`;
else {
// add OUTPUT expression
if (returningExpression &&
this.dataSource.driver.options.type === "mssql") {
query += ` OUTPUT ${returningExpression}`;
}
// add VALUES expression
if (valuesExpression) {
if ((this.dataSource.driver.options.type === "oracle" ||
this.dataSource.driver.options.type === "sap") &&
this.getValueSets().length > 1) {
query += ` ${valuesExpression}`;
}
else {
query += ` VALUES ${valuesExpression}`;
}
}
else {
if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "aurora-mysql") {
// special syntax for mysql DEFAULT VALUES insertion
query += " VALUES ()";
}
else {
query += ` DEFAULT VALUES`;
}
}
}
if (this.expressionMap.onUpdate?.upsertType !== "primary-key") {
if (this.dataSource.driver.supportedUpsertTypes.includes("on-conflict-do-update")) {
if (this.expressionMap.onIgnore) {
query += " ON CONFLICT DO NOTHING ";
}
else if (this.expressionMap.onUpdate) {
const { overwrite, columns, conflict, skipUpdateIfNoValuesChanged, indexPredicate, } = this.expressionMap.onUpdate;
let conflictTarget = "ON CONFLICT";
if (Array.isArray(conflict)) {
conflictTarget += ` ( ${conflict
.map((column) => this.escape(column))
.join(", ")} )`;
if (indexPredicate &&
!DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver)) {
throw new error_1.TypeORMError(`indexPredicate option is not supported by the current database driver`);
}
if (indexPredicate &&
DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver)) {
conflictTarget += ` WHERE ( ${indexPredicate} )`;
}
}
else if (conflict) {
conflictTarget += ` ON CONSTRAINT ${this.escape(conflict)}`;
}
const updatePart = [];
if (Array.isArray(overwrite)) {
updatePart.push(...overwrite.map((column) => `${this.escape(column)} = EXCLUDED.${this.escape(column)}`));
}
else if (columns) {
updatePart.push(...columns.map((column) => {
let expression = `:${column}`;
if (this.expressionMap.mainAlias.hasMetadata &&
DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver)) {
const col = this.expressionMap.mainAlias?.metadata.findColumnWithDatabaseName(column);
if (col) {
expression = this.dataSource.driver.wrapWithJsonFunction(expression, col, true);
}
}
return `${this.escape(column)} = ${expression}`;
}));
}
if (updatePart.length === 0) {
query += ` ${conflictTarget} DO NOTHING `;
}
else {
query += ` ${conflictTarget} DO UPDATE SET `;
if (this.expressionMap.mainAlias.hasMetadata) {
updatePart.push(...this.expressionMap
.mainAlias.metadata.columns.filter((column) => column.isUpdateDate &&
!overwrite?.includes(column.databaseName) &&
!((this.dataSource.driver.options
.type === "oracle" &&
this.getValueSets().length >
1) ||
DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver) ||
this.dataSource.driver.options
.type === "sap" ||
this.dataSource.driver.options
.type === "spanner"))
.map((column) => `${this.escape(column.databaseName)} = DEFAULT`));
}
query += updatePart.join(", ");
}
if (Array.isArray(overwrite) &&
overwrite.length > 0 &&
skipUpdateIfNoValuesChanged) {
this.expressionMap.onUpdate.overwriteCondition ??= [];
const wheres = overwrite.map((column) => ({
type: "or",
condition: `${tableOrAliasName}.${this.escape(column)} IS DISTINCT FROM EXCLUDED.${this.escape(column)}`,
}));
this.expressionMap.onUpdate.overwriteCondition.push({
type: "and",
condition: wheres,
});
}
if (DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver) &&
this.expressionMap.onUpdate.overwriteCondition &&
this.expressionMap.onUpdate.overwriteCondition.length >
0) {
query += ` WHERE ${this.createUpsertConditionExpression(tableOrAliasName)}`;
}
}
}
else if (this.dataSource.driver.supportedUpsertTypes.includes("on-duplicate-key-update")) {
if (this.expressionMap.onUpdate) {
const { overwrite, columns } = this.expressionMap.onUpdate;
if (Array.isArray(overwrite) && overwrite.length === 0) {
// No columns to update — degrade to INSERT IGNORE
// The IGNORE keyword was not added above, so we
// rewrite the query to include it.
query = query.replace(/^INSERT INTO/, "INSERT IGNORE INTO");
}
else if (Array.isArray(overwrite)) {
query += " ON DUPLICATE KEY UPDATE ";
query += overwrite
.map((column) => `${this.escape(column)} = VALUES(${this.escape(column)})`)
.join(", ");
query += " ";
}
else if (Array.isArray(columns)) {
query += " ON DUPLICATE KEY UPDATE ";
query += columns
.map((column) => `${this.escape(column)} = :${column}`)
.join(", ");
query += " ";
}
}
}
else {
if (this.expressionMap.onUpdate) {
throw new error_1.TypeORMError(`onUpdate is not supported by the current database driver`);
}
}
}
// add RETURNING expression
// Note: Oracle does not support RETURNING with INSERT ... SELECT (insertFromSelect),
// so we skip RETURNING for Oracle when inserting from a select.
if (returningExpression &&
(DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "cockroachdb" ||
DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
(this.dataSource.driver.options.type === "oracle" &&
!this.expressionMap.insertFromSelect))) {
query += ` RETURNING ${returningExpression}`;
}
if (returningExpression &&
this.dataSource.driver.options.type === "spanner") {
query += ` THEN RETURN ${returningExpression}`;
}
// Inserting a specific value for an auto-increment primary key in mssql requires enabling IDENTITY_INSERT
// IDENTITY_INSERT can only be enabled for tables where there is an IDENTITY column and only if there is a value to be inserted (i.e. supplying DEFAULT is prohibited if IDENTITY_INSERT is enabled)
if (this.dataSource.driver.options.type === "mssql" &&
this.expressionMap.mainAlias.hasMetadata &&
this.expressionMap
.mainAlias.metadata.columns.filter((column) => this.expressionMap.insertColumns.length > 0
? this.expressionMap.insertColumns.indexOf(column.propertyPath) !== -1
: column.isInsert)
.some((column) => this.isOverridingAutoIncrementBehavior(column))) {
query = `SET IDENTITY_INSERT ${tableName} ON; ${query}; SET IDENTITY_INSERT ${tableName} OFF`;
}
return query;
}
/**
* Gets list of columns where values must be inserted to.
*/
getInsertedColumns() {
if (!this.expressionMap.mainAlias.hasMetadata)
return [];
return this.expressionMap.mainAlias.metadata.columns.filter((column) => {
// if user specified list of columns he wants to insert to, then we filter only them
if (this.expressionMap.insertColumns.length)
return (this.expressionMap.insertColumns.indexOf(column.propertyPath) !== -1);
// skip columns the user doesn't want included by default
if (!column.isInsert) {
return false;
}
// Skip generated columns if we are inserting from select, if not explicitly specified
if (column.isGenerated &&
this.expressionMap.insertFromSelect &&
(DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver) ||
DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type ===
"aurora-mysql" ||
this.dataSource.driver.options.type === "oracle"))
return false;
// if user did not specified such list then return all columns except auto-increment one
// for Oracle we return auto-increment column as well because Oracle does not support DEFAULT VALUES expression
if (column.isGenerated &&
column.generationStrategy === "increment" &&
!(this.dataSource.driver.options.type === "spanner") &&
!(this.dataSource.driver.options.type === "oracle") &&
!DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver) &&
!DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) &&
!(this.dataSource.driver.options.type === "aurora-mysql") &&
!(this.dataSource.driver.options.type === "mssql" &&
this.isOverridingAutoIncrementBehavior(column)))
return false;
return true;
});
}
/**
* Creates a columns string where values must be inserted to for INSERT INTO expression.
*/
createColumnNamesExpression() {
const columns = this.getInsertedColumns();
if (columns.length > 0)
return columns
.map((column) => this.escape(column.databaseName))
.join(", ");
// in the case if there are no insert columns specified and table without metadata used
// we get columns from the inserted value map, in the case if only one inserted map is specified
if (!this.expressionMap.mainAlias.hasMetadata &&
!this.expressionMap.insertColumns.length) {
const valueSets = this.getValueSets();
if (valueSets.length === 1)
return Object.keys(valueSets[0])
.map((columnName) => this.escape(columnName))
.join(", ");
}
// get a table name and all column database names
return this.expressionMap.insertColumns
.map((columnName) => this.escape(columnName))
.join(", ");
}
/**
* Creates list of values needs to be inserted in the VALUES expression.
*/
createValuesExpression() {
const valueSets = this.getValueSets();
const columns = this.getInsertedColumns();
// if column metadatas are given then apply all necessary operations with values
if (columns.length > 0) {
let expression = "";
valueSets.forEach((valueSet, valueSetIndex) => {
columns.forEach((column, columnIndex) => {
if (columnIndex === 0) {
if (this.dataSource.driver.options.type === "oracle" &&
valueSets.length > 1) {
expression += " SELECT ";
}
else if (this.dataSource.driver.options.type === "sap" &&
valueSets.length > 1) {
expression += " SELECT ";
}
else {
expression += "(";
}
}
expression += this.createColumnValueExpression(valueSets, valueSetIndex, column);
if (columnIndex === columns.length - 1) {
if (valueSetIndex === valueSets.length - 1) {
if (["oracle", "sap"].includes(this.dataSource.driver.options.type) &&
valueSets.length > 1) {
expression +=
" FROM " +
this.dataSource.driver.dummyTableName;
}
else {
expression += ")";
}
}
else {
if (["oracle", "sap"].includes(this.dataSource.driver.options.type) &&
valueSets.length > 1) {
expression +=
" FROM " +
this.dataSource.driver.dummyTableName +
" UNION ALL ";
}
else {
expression += "), ";
}
}
}
else {
expression += ", ";
}
});
});
if (expression === "()")
return "";
return expression;
}
else {
// for tables without metadata
// get values needs to be inserted
let expression = "";
valueSets.forEach((valueSet, insertionIndex) => {
const columns = Object.keys(valueSet);
columns.forEach((columnName, columnIndex) => {
if (columnIndex === 0) {
expression += "(";
}
const value = valueSet[columnName];
// support for SQL expressions in queries
if (typeof value === "function") {
expression += value();
// if value for this column was not provided then insert default value
}
else if (value === undefined) {
if ((this.dataSource.driver.options.type === "oracle" &&
valueSets.length > 1) ||
DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "sap" ||
this.dataSource.driver.options.type === "spanner") {
expression += "NULL";
}
else {
expression += "DEFAULT";
}
}
else if (value === null &&
this.dataSource.driver.options.type === "spanner") {
// just any other regular value
}
else {
expression += this.createParameter(value);
}
if (columnIndex === Object.keys(valueSet).length - 1) {
if (insertionIndex === valueSets.length - 1) {
expression += ")";
}
else {
expression += "), ";
}
}
else {
expression += ", ";
}
});
});
if (expression === "()")
return "";
return expression;
}
}
/**
* Gets array of values need to be inserted into the target table.
*/
getValueSets() {
if (this.expressionMap.insertFromSelect) {
return [];
}
if (Array.isArray(this.expressionMap.valuesSet))
return this.expressionMap.valuesSet;
if (ObjectUtils_1.ObjectUtils.isObject(this.expressionMap.valuesSet))
return [this.expressionMap.valuesSet];
throw new InsertValuesMissingError_1.InsertValuesMissingError();
}
/**
* Checks if column is an auto-generated primary key, but the current insertion specifies a value for it.
*
* @param column
*/
isOverridingAutoIncrementBehavior(column) {
return (column.isPrimary &&
column.isGenerated &&
column.generationStrategy === "increment" &&
this.getValueSets().some((valueSet) => column.getEntityValue(valueSet) !== undefined &&
column.getEntityValue(valueSet) !== null));
}
/**
* Creates MERGE express used to perform insert query.
*/
createMergeExpression() {
if (!this.dataSource.driver.supportedUpsertTypes.includes("merge-into"))
throw new error_1.TypeORMError(`Upsert type "merge-into" is not supported by current database driver`);
if (this.expressionMap.onUpdate?.upsertType &&
this.expressionMap.onUpdate.upsertType !== "merge-into") {
throw new error_1.TypeORMError(`Upsert type "${this.expressionMap.onUpdate.upsertType}" is not supported by current database driver`);
}
// const mainAlias = this.expressionMap.mainAlias!
const tableName = this.getTableName(this.getMainTableName());
const tableAlias = this.escape(this.alias);
const columns = this.getInsertedColumns();
const columnsExpression = this.createColumnNamesExpression();
let query = `MERGE INTO ${tableName} ${this.escape(this.alias)}`;
const mergeSourceAlias = this.escape("mergeIntoSource");
const mergeSourceExpression = this.createMergeIntoSourceExpression(mergeSourceAlias);
query += ` ${mergeSourceExpression}`;
// build on condition
if (this.expressionMap.onIgnore) {
const primaryKey = columns.find((column) => column.isPrimary);
if (primaryKey) {
query += ` ON (${tableAlias}.${this.escape(primaryKey.databaseName)} = ${mergeSourceAlias}.${this.escape(primaryKey.databaseName)})`;
}
else {
// Get unique constraints from metadata.uniques
const uniqueConstraints = this.expressionMap.mainAlias.metadata.uniques;
// Get unique indices from metadata.indices
const uniqueIndices = this.expressionMap.mainAlias.metadata.indices.filter((index) => index.isUnique);
const allUniqueConditions = [];
// Add conditions from unique constraints
uniqueConstraints.forEach((unique) => {
const condition = unique.columns
.map((column) => {
return `${tableAlias}.${this.escape(column.databaseName)} = ${mergeSourceAlias}.${this.escape(column.databaseName)}`;
})
.join(" AND ");
allUniqueConditions.push(`(${condition})`);
});
// Add conditions from unique indices
uniqueIndices.forEach((index) => {
const condition = index.columns
.map((column) => {
return `${tableAlias}.${this.escape(column.databaseName)} = ${mergeSourceAlias}.${this.escape(column.databaseName)}`;
})
.join(" AND ");
allUniqueConditions.push(`(${condition})`);
});
if (allUniqueConditions.length > 0) {
query += ` ON (${allUniqueConditions.join(" OR ")})`;
}
else {
// Fallback: use all columns being inserted as the match condition
const columnConditions = columns
.map((column) => {
return `${tableAlias}.${this.escape(column.databaseName)} = ${mergeSourceAlias}.${this.escape(column.databaseName)}`;
})
.join(" AND ");
query += ` ON (${columnConditions})`;
}
}
}
else if (this.expressionMap.onUpdate) {
const { conflict, indexPredicate } = this.expressionMap.onUpdate;
if (indexPredicate) {
throw new error_1.TypeORMError(`indexPredicate option is not supported by upsert type "merge-into"`);
}
if (Array.isArray(conflict)) {
query += ` ON (${conflict
.map((column) => `${tableAlias}.${this.escape(column)} = ${mergeSourceAlias}.${this.escape(column)}`)
.join(" AND ")})`;
}
else if (conflict) {
query += ` ON (${tableAlias}.${this.escape(conflict)} = ${mergeSourceAlias}.${this.escape(conflict)})`;
}
else {
query += `ON (${this.expressionMap
.mainAlias.metadata.uniques.map((unique) => {
return `(${unique.columns
.map((column) => {
return `${tableAlias}.${this.escape(column.databaseName)} = ${mergeSourceAlias}.${this.escape(column.databaseName)}`;
})
.join(" AND ")})`;
})
.join(" OR ")})`;
}
}
if (this.expressionMap.onUpdate) {
const { overwrite, columns, conflict, skipUpdateIfNoValuesChanged, } = this.expressionMap.onUpdate;
let updateExpression = "";
if (Array.isArray(overwrite)) {
updateExpression += (overwrite || columns)
?.filter((column) => !conflict?.includes(column))
.map((column) => `${tableAlias}.${this.escape(column)} = ${mergeSourceAlias}.${this.escape(column)}`)
.join(", ");
}
if (Array.isArray(overwrite) && skipUpdateIfNoValuesChanged) {
this.expressionMap.onUpdate.overwriteCondition ??= [];
const wheres = overwrite.map((column) => ({
type: "or",
condition: {
operator: "notEqual",
parameters: [
`${tableAlias}.${this.escape(column)}`,
`${mergeSourceAlias}.${this.escape(column)}`,
],
},
}));
this.expressionMap.onUpdate.overwriteCondition.push({
type: "and",
condition: wheres,
});
}
const mergeCondition = this.createUpsertConditionExpression(tableAlias);
if (updateExpression.trim()) {
if ((this.dataSource.driver.options.type === "mssql" ||
this.dataSource.driver.options.type === "sap") &&
mergeCondition != "") {
query += ` WHEN MATCHED AND ${mergeCondition} THEN UPDATE SET ${updateExpression}`;
}
else {
query += ` WHEN MATCHED THEN UPDATE SET ${updateExpression}`;
if (mergeCondition != "") {
query += ` WHERE ${mergeCondition}`;
}
}
}
}
const valuesExpression = this.createMergeIntoInsertValuesExpression(mergeSourceAlias);
const returningExpression = this.dataSource.driver.options.type === "mssql"
? this.createReturningExpression("insert")
: null;
query += " WHEN NOT MATCHED THEN INSERT";
// add columns expression
if (columnsExpression) {
query += `(${columnsExpression})`;
}
// add VALUES expression
if (valuesExpression) {
query += ` VALUES ${valuesExpression}`;
}
// add OUTPUT expression
if (returningExpression &&
this.dataSource.driver.options.type === "mssql") {
query += ` OUTPUT ${returningExpression}`;
}
if (this.dataSource.driver.options.type === "mssql") {
query += `;`;
}
return query;
}
/**
* Creates list of values needs to be inserted in the VALUES expression.
*
* @param mergeSourceAlias
*/
createMergeIntoSourceExpression(mergeSourceAlias) {
const columns = this.getInsertedColumns();
let expression = "USING (";
// Handle INSERT FROM SELECT case
if (this.expressionMap.insertFromSelect) {
// For MERGE source we need the SELECT's output columns to match
// the target column names referenced as `mergeIntoSource.<col>`.
// MSSQL supports providing a column list after the alias, so
// in that case we can keep the original SELECT. For other
// drivers (e.g. Oracle, SAP HANA) we clone the select and set
// the select aliases to the target column database names so
// references like `mergeIntoSource.email` resolve correctly.
if (this.dataSource.driver.options.type === "mssql") {
expression += this.expressionMap.insertFromSelect.getQuery();
}
else {
// Clone the SelectQueryBuilder and modify its select expressions
const selectQb = this.expressionMap.insertFromSelect.clone();
const targetColumns = this.getInsertedColumns();
// Clear existing selects and add new ones with proper aliases
selectQb.expressionMap.selects = [];
// Get the original select expressions
const originalSelects = this.expressionMap.insertFromSelect.expressionMap.selects;
originalSelects.forEach((select, index) => {
const targetColumn = targetColumns[index];
if (targetColumn) {
// Add select with target column name as alias
selectQb.expressionMap.selects.push({
selection: select.selection,
aliasName: targetColumn.databaseName,
virtual: select.virtual,
});
}
else {
selectQb.expressionMap.selects.push(select);
}
});
expression += selectQb.getQuery();
}
expression += `) ${mergeSourceAlias}`;
// MSSQL requires column list after the alias
if (this.dataSource.driver.options.type === "mssql") {
expression += ` (${columns
.map((column) => this.escape(column.databaseName))
.join(", ")})`;
}
return expression;
}
// Handle VALUES case
const valueSets = this.getValueSets();
// if column metadatas are given then apply all necessary operations with values
if (columns.length > 0) {
if (this.dataSource.driver.options.type === "mssql") {
expression += "VALUES ";
}
valueSets.forEach((valueSet, valueSetIndex) => {
columns.forEach((column, columnIndex) => {
if (columnIndex === 0) {
if (this.dataSource.driver.options.type === "mssql") {
expression += "(";
}
else {
expression += "SELECT ";
}
}
const value = column.getEntityValue(valueSet);
if (value === undefined &&
!(column.isGenerated &&
column.generationStrategy === "uuid" &&
!this.dataSource.driver.isUUIDGenerationSupported())) {
if (column.default !== undefined &&
column.default !== null) {
// try to use default defined in the column
expression +=
this.dataSource.driver.normalizeDefault(column);
}
else {
expression += "NULL"; // otherwise simply use NULL and pray if column is nullable
}
}
else if (value === null) {
expression += "NULL";
}
else {
expression += this.createColumnValueExpression(valueSets, valueSetIndex, column);
}
if (this.dataSource.driver.options.type !== "mssql")
expression += ` AS ${this.escape(column.databaseName)}`;
if (columnIndex === columns.length - 1) {
if (valueSetIndex === valueSets.length - 1) {
if (["oracle", "sap"].includes(this.dataSource.driver.options.type)) {
expression +=
" FROM " +
this.dataSource.driver.dummyTableName;
}
else if (this.dataSource.driver.options.type === "mssql") {
expression += ")";
}
}
else {
if (["oracle", "sap"].includes(this.dataSource.driver.options.type) &&
valueSets.length > 1) {
expression +=
" FROM " +
this.dataSource.driver.dummyTableName +
" UNION ALL ";
}
else if (this.dataSource.driver.options.type === "mssql") {
expression += "), ";
}
else {
expression += " UNION ALL ";
}
}
}
else {
expression += ", ";
}
});
});
}
else {
// for tables without metadata
throw new error_1.TypeORMError('Upsert type "merge-into" is not supported without metadata tables');
}
expression += `) ${mergeSourceAlias}`;
if (this.dataSource.driver.options.type === "mssql")
expression += ` (${columns
.map((column) => this.escape(column.databaseName))
.join(", ")})`;
return expression;
}
/**
* Creates list of values needs to be inserted in the VALUES expression.
*
* @param mergeSourceAlias
*/
createMergeIntoInsertValuesExpression(mergeSourceAlias) {
const columns = this.getInsertedColumns();
let expression = "";
// if column metadatas are given then apply all necessary operations with values
if (columns.length > 0) {
columns.forEach((column, columnIndex) => {
if (columnIndex === 0) {
expression += "(";
}
if ((column.isGenerated &&
column.generationStrategy === "uuid" &&
this.dataSource.driver.isUUIDGenerationSupported()) ||
(column.isGenerated && column.generationStrategy !== "uuid")) {
expression += `DEFAULT`;
}
else {
expression += `${mergeSourceAlias}.${this.escape(column.databaseName)}`;
}
if (columnIndex === columns.length - 1) {
expression += ")";
}
else {
expression += ", ";
}
});
}
else {
// for tables without metadata
throw new error_1.TypeORMError('Upsert type "merge-into" is not supported without metadata tables');
}
if (expression === "()")
return "";
return expression;
}
/**
* Create upsert search condition expression.
*
* @param mainTableOrAlias
*/
createUpsertConditionExpression(mainTableOrAlias) {
if (!this.expressionMap.onUpdate.overwriteCondition)
return "";
const conditionsArray = [];
const whereExpression = this.createWhereClausesExpression(this.expressionMap.onUpdate.overwriteCondition);
if (whereExpression.length > 0 && whereExpression !== "1=1") {
conditionsArray.push(whereExpression);
}
if (this.expressionMap.mainAlias.hasMetadata) {
const metadata = this.expressionMap.mainAlias.metadata;
// Adds the global condition of "non-deleted" for the entity with delete date columns in select query.
if (this.expressionMap.queryType === "select" &&
!this.expressionMap.withDeleted &&
metadata.deleteDateColumn) {
const column = this.expressionMap.aliasNamePrefixingEnabled
? this.expressionMap.mainAlias.name +
"." +
metadata.deleteDateColumn.propertyName
: metadata.deleteDateColumn.propertyName;
const condition = `${column} IS NULL`;
conditionsArray.push(condition);
}
if (metadata.discriminatorColumn && metadata.parentEntityMetadata) {
const column = this.expressionMap.aliasNamePrefixingEnabled
? mainTableOrAlias +
"." +
this.escape(metadata.discriminatorColumn.databaseName)
: this.escape(metadata.discriminatorColumn.databaseName);
const condition = `${column} IN (:...discriminatorColumnValues)`;
conditionsArray.push(condition);
}
}
if (this.expressionMap.extraAppendedAndWhereCondition) {
const condition = this.expressionMap.extraAppendedAndWhereCondition;
conditionsArray.push(condition);
}
let condition = "";
if (!conditionsArray.length) {
condition += "";
}
else if (conditionsArray.length === 1) {
condition += `${conditionsArray[0]}`;
}
else {
condition += `( ${conditionsArray.join(" ) AND ( ")} )`;
}
return condition;
}
createColumnValueExpression(valueSets, valueSetIndex, column) {
const valueSet = valueSets[valueSetIndex];
let expression = "";
// extract real value from the entity
let value = column.getEntityValue(valueSet);
if (!(typeof value === "function")) {
// make sure our value is normalized by a driver
value = this.dataSource.driver.preparePersistentValue(value, column);
}
// newly inserted entities always have a version equal to 1 (first version)
// also, user-specified version must be empty
if (column.isVersion && value === undefined) {
expression += "1";
// } else if (column.isNestedSetLeft) {
// const tableName = this.dataSource.driver.escape(column.entityMetadata.tablePath);
// const rightColumnName = this.dataSource.driver.escape(column.entityMetadata.nestedSetRightColumn!.databaseName);
// const subQuery = `(SELECT c.max + 1 FROM (SELECT MAX(${rightColumnName}) as max from ${tableName}) c)`;
// expression += subQuery;
//
// } else if (column.isNestedSetRight) {
// const tableName = this.dataSource.driver.escape(column.entityMetadata.tablePath);
// const rightColumnName = this.dataSource.driver.escape(column.entityMetadata.nestedSetRightColumn!.databaseName);
// const subQuery = `(SELECT c.max + 2 FROM (SELECT MAX(${rightColumnName}) as max from ${tableName}) c)`;
// expression += subQuery;
}
else if (column.isDiscriminator) {
expression += this.createParameter(this.expressionMap.mainAlias.metadata.discriminatorValue);
// return "1";
// for create and update dates we insert current date
// no, we don't do it because this constant is already in "default" value of the column
// with extended timestamp functionality, like CURRENT_TIMESTAMP(6) for example
// } else if (column.isCreateDate || column.isUpdateDate) {
// return "CURRENT_TIMESTAMP";
// if column is generated uuid and database does not support its generation and custom generated value was not provided by a user - we generate a new uuid value for insertion
}
else if (column.isGenerated &&
column.generationStrategy === "uuid" &&
!this.dataSource.driver.isUUIDGenerationSupported() &&
value === undefined) {
value = RandomGenerator_1.RandomGenerator.uuidv4();
expression += this.createParameter(value);
if (!(valueSetIndex in this.expressionMap.locallyGenerated)) {
this.expressionMap.locallyGenerated[valueSetIndex] = {};
}
column.setEntityValue(this.expressionMap.locallyGenerated[valueSetIndex], value);
// if value for this column was not provided then insert default value
}
else if (value === undefined) {
if ((this.dataSource.driver.options.type === "oracle" &&
valueSets.length > 1) ||
DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "sap" ||
this.dataSource.driver.options.type === "spanner") {
// unfortunately sqlite does not support DEFAULT expression in INSERT queries
if (column.default !== undefined && column.default !== null) {
// try to use default defined in the column
expression +=
this.dataSource.driver.normalizeDefault(column);
}
else if (this.dataSource.driver.options.type === "spanner" &&
column.isGenerated &&
column.generationStrategy === "uuid") {
expression += "GENERATE_UUID()"; // Produces a random universally unique identifier (UUID) as a STRING value.
}
else {
expression += "NULL"; // otherwise simply use NULL and pray if column is nullable
}
}
else {
expression += "DEFAULT";
}
}
else if (value === null &&
(this.dataSource.driver.options.type === "spanner" ||
this.dataSource.driver.options.type === "oracle")) {
expression += "NULL";
// support for SQL expressions in queries
}
else if (typeof value === "function") {
expression += value();
// just any other regular value
}
else {
if (this.dataSource.driver.options.type === "mssql")
value = this.dataSource.driver.parametrizeValue(column, value);
// we need to store array values in a special class to make sure parameter replacement will work correctly
// if (value instanceof Array)
// value = new ArrayParameter(value);
const paramName = this.createParameter(value);
if ((DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
this.dataSource.driver.options.type === "aurora-mysql") &&
this.dataSource.driver.spatialTypes.includes(column.type)) {
const useLegacy = this.dataSource.driver.options.legacySpatialSupport;
const geomFromText = useLegacy
? "GeomFromText"
: "ST_GeomFromText";
if (column.srid != null) {
expression += `${geomFromText}(${paramName}, ${column.srid})`;
}
else {
expression += `${geomFromText}(${paramName})`;
}
}
else if (DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver) &&
this.dataSource.driver.spatialTypes.includes(column.type)) {
if (column.srid != null) {
expression += `ST_SetSRID(ST_GeomFromGeoJSON(${paramName}), ${column.srid})::${column.type}`;
}
else {
expression += `ST_GeomFromGeoJSON(${paramName})::${column.type}`;
}
}
else if (this.dataSource.driver.options.type === "mssql" &&
this.dataSource.driver.spatialTypes.includes(column.type)) {
expression +=
column.type +
"::STGeomFromText(" +
paramName +
", " +
(column.srid ?? "0") +
")";
}
else if (DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver)) {
expression = this.dataSource.driver.wrapWithJsonFunction(paramName, column, true);
}
else {
expression += paramName;
}
}
return expression;
}
}
exports.InsertQueryBuilder = InsertQueryBuilder;
//# sourceMappingURL=InsertQueryBuilder.js.map