first commit

packages/nodes-base/nodes/MySql/v2/MySqlV2.node.ts

@@ -0,0 +1,28 @@
+import type {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeBaseDescription,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+
+import { router } from './actions/router';
+import { versionDescription } from './actions/versionDescription';
+import { listSearch, credentialTest, loadOptions } from './methods';
+
+export class MySqlV2 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			...versionDescription,
+		};
+	}
+
+	methods = { listSearch, loadOptions, credentialTest };
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		return await router.call(this);
+	}
+}

packages/nodes-base/nodes/MySql/v2/actions/common.descriptions.ts

@@ -0,0 +1,386 @@
+import type { INodeProperties, INodePropertyOptions } from 'n8n-workflow';
+
+import { BATCH_MODE, SINGLE } from '../helpers/interfaces';
+
+export const operatorOptions: INodePropertyOptions[] = [
+	{
+		name: 'Equal',
+		value: 'equal',
+	},
+	{
+		name: 'Not Equal',
+		value: '!=',
+	},
+	{
+		name: 'Like',
+		value: 'LIKE',
+	},
+	{
+		name: 'Greater Than',
+		value: '>',
+	},
+	{
+		name: 'Less Than',
+		value: '<',
+	},
+	{
+		name: 'Greater Than Or Equal',
+		value: '>=',
+	},
+	{
+		name: 'Less Than Or Equal',
+		value: '<=',
+	},
+	{
+		name: 'Is Null',
+		value: 'IS NULL',
+	},
+	{
+		name: 'Is Not Null',
+		value: 'IS NOT NULL',
+	},
+];
+
+export const tableRLC: INodeProperties = {
+	displayName: 'Table',
+	name: 'table',
+	type: 'resourceLocator',
+	default: { mode: 'list', value: '' },
+	required: true,
+	description: 'The table you want to work on',
+	modes: [
+		{
+			displayName: 'From List',
+			name: 'list',
+			type: 'list',
+			placeholder: 'Select a Table...',
+			typeOptions: {
+				searchListMethod: 'searchTables',
+				searchable: true,
+			},
+		},
+		{
+			displayName: 'Name',
+			name: 'name',
+			type: 'string',
+			placeholder: 'table_name',
+		},
+	],
+};
+
+export const optionsCollection: INodeProperties = {
+	displayName: 'Options',
+	name: 'options',
+	type: 'collection',
+	default: {},
+	placeholder: 'Add option',
+	options: [
+		{
+			displayName: 'Connection Timeout',
+			name: 'connectionTimeoutMillis',
+			type: 'number',
+			default: 30,
+			description: 'Number of milliseconds reserved for connecting to the database',
+			typeOptions: {
+				minValue: 1,
+			},
+		},
+		{
+			displayName: 'Connections Limit',
+			name: 'connectionLimit',
+			type: 'number',
+			default: 10,
+			typeOptions: {
+				minValue: 1,
+			},
+			description:
+				'Maximum amount of connections to the database, setting high value can lead to performance issues and potential database crashes',
+		},
+		{
+			displayName: 'Query Batching',
+			name: 'queryBatching',
+			type: 'options',
+			noDataExpression: true,
+			description: 'The way queries should be sent to the database',
+			options: [
+				{
+					name: 'Single Query',
+					value: BATCH_MODE.SINGLE,
+					description: 'A single query for all incoming items',
+				},
+				{
+					name: 'Independent',
+					value: BATCH_MODE.INDEPENDENTLY,
+					description: 'Execute one query per incoming item of the run',
+				},
+				{
+					name: 'Transaction',
+					value: BATCH_MODE.TRANSACTION,
+					description:
+						'Execute all queries in a transaction, if a failure occurs, all changes are rolled back',
+				},
+			],
+			default: SINGLE,
+		},
+		{
+			displayName: 'Query Parameters',
+			name: 'queryReplacement',
+			type: 'string',
+			default: '',
+			placeholder: 'e.g. value1,value2,value3',
+			description:
+				'Comma-separated list of the values you want to use as query parameters. You can drag the values from the input panel on the left. <a href="https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.mysql/" target="_blank">More info</a>',
+			hint: 'Comma-separated list of values: reference them in your query as $1, $2, $3…',
+			displayOptions: {
+				show: { '/operation': ['executeQuery'] },
+			},
+		},
+		{
+			// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-multi-options
+			displayName: 'Output Columns',
+			name: 'outputColumns',
+			type: 'multiOptions',
+			// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-multi-options
+			description:
+				'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+			typeOptions: {
+				loadOptionsMethod: 'getColumnsMultiOptions',
+				loadOptionsDependsOn: ['table.value'],
+			},
+			default: [],
+			displayOptions: {
+				show: { '/operation': ['select'] },
+			},
+		},
+		{
+			displayName: 'Output Large-Format Numbers As',
+			name: 'largeNumbersOutput',
+			type: 'options',
+			options: [
+				{
+					name: 'Numbers',
+					value: 'numbers',
+				},
+				{
+					name: 'Text',
+					value: 'text',
+					description:
+						'Use this if you expect numbers longer than 16 digits (otherwise numbers may be incorrect)',
+				},
+			],
+			hint: 'Applies to NUMERIC and BIGINT columns only',
+			default: 'text',
+			displayOptions: {
+				show: { '/operation': ['select', 'executeQuery'] },
+			},
+		},
+		{
+			displayName: 'Output Decimals as Numbers',
+			name: 'decimalNumbers',
+			type: 'boolean',
+			default: false,
+			description: 'Whether to output DECIMAL types as numbers instead of strings',
+			displayOptions: {
+				show: { '/operation': ['select', 'executeQuery'] },
+			},
+		},
+		{
+			displayName: 'Priority',
+			name: 'priority',
+			type: 'options',
+			options: [
+				{
+					name: 'Low Prioirity',
+					value: 'LOW_PRIORITY',
+					description:
+						'Delays execution of the INSERT until no other clients are reading from the table',
+				},
+				{
+					name: 'High Priority',
+					value: 'HIGH_PRIORITY',
+					description:
+						'Overrides the effect of the --low-priority-updates option if the server was started with that option. It also causes concurrent inserts not to be used.',
+				},
+			],
+			default: 'LOW_PRIORITY',
+			description: 'Ignore any ignorable errors that occur while executing the INSERT statement',
+			displayOptions: {
+				show: {
+					'/operation': ['insert'],
+				},
+			},
+		},
+		{
+			displayName: 'Replace Empty Strings with NULL',
+			name: 'replaceEmptyStrings',
+			type: 'boolean',
+			default: false,
+			description:
+				'Whether to replace empty strings with NULL in input, could be useful when data come from spreadsheet',
+			displayOptions: {
+				show: {
+					'/operation': ['insert', 'update', 'upsert', 'executeQuery'],
+				},
+			},
+		},
+		{
+			displayName: 'Select Distinct',
+			name: 'selectDistinct',
+			type: 'boolean',
+			default: false,
+			description: 'Whether to remove these duplicate rows',
+			displayOptions: {
+				show: {
+					'/operation': ['select'],
+				},
+			},
+		},
+		{
+			displayName: 'Output Query Execution Details',
+			name: 'detailedOutput',
+			type: 'boolean',
+			default: false,
+			description:
+				'Whether to show in output details of the ofexecuted query for each statement, or just confirmation of success',
+		},
+		{
+			displayName: 'Skip on Conflict',
+			name: 'skipOnConflict',
+			type: 'boolean',
+			default: false,
+			description:
+				'Whether to skip the row and do not throw error if a unique constraint or exclusion constraint is violated',
+			displayOptions: {
+				show: {
+					'/operation': ['insert'],
+				},
+			},
+		},
+	],
+};
+
+export const selectRowsFixedCollection: INodeProperties = {
+	displayName: 'Select Rows',
+	name: 'where',
+	type: 'fixedCollection',
+	typeOptions: {
+		multipleValues: true,
+	},
+	placeholder: 'Add Condition',
+	default: {},
+	description: 'If not set, all rows will be selected',
+	options: [
+		{
+			displayName: 'Values',
+			name: 'values',
+			values: [
+				{
+					// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+					displayName: 'Column',
+					name: 'column',
+					type: 'options',
+					// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+					description:
+						'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+					default: '',
+					placeholder: 'e.g. ID',
+					typeOptions: {
+						loadOptionsMethod: 'getColumns',
+						loadOptionsDependsOn: ['schema.value', 'table.value'],
+					},
+				},
+				{
+					displayName: 'Operator',
+					name: 'condition',
+					type: 'options',
+					description:
+						"The operator to check the column against. When using 'LIKE' operator percent sign ( %) matches zero or more characters, underscore ( _ ) matches any single character.",
+					// eslint-disable-next-line n8n-nodes-base/node-param-options-type-unsorted-items
+					options: operatorOptions,
+					default: 'equal',
+				},
+				{
+					displayName: 'Value',
+					name: 'value',
+					type: 'string',
+					displayOptions: {
+						hide: {
+							condition: ['IS NULL', 'IS NOT NULL'],
+						},
+					},
+					default: '',
+				},
+			],
+		},
+	],
+};
+
+export const sortFixedCollection: INodeProperties = {
+	displayName: 'Sort',
+	name: 'sort',
+	type: 'fixedCollection',
+	typeOptions: {
+		multipleValues: true,
+	},
+	placeholder: 'Add Sort Rule',
+	default: {},
+	options: [
+		{
+			displayName: 'Values',
+			name: 'values',
+			values: [
+				{
+					// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+					displayName: 'Column',
+					name: 'column',
+					type: 'options',
+					// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+					description:
+						'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+					default: '',
+					typeOptions: {
+						loadOptionsMethod: 'getColumns',
+						loadOptionsDependsOn: ['schema.value', 'table.value'],
+					},
+				},
+				{
+					displayName: 'Direction',
+					name: 'direction',
+					type: 'options',
+					options: [
+						{
+							name: 'ASC',
+							value: 'ASC',
+						},
+						{
+							name: 'DESC',
+							value: 'DESC',
+						},
+					],
+					default: 'ASC',
+				},
+			],
+		},
+	],
+};
+
+export const combineConditionsCollection: INodeProperties = {
+	displayName: 'Combine Conditions',
+	name: 'combineConditions',
+	type: 'options',
+	description:
+		'How to combine the conditions defined in "Select Rows": AND requires all conditions to be true, OR requires at least one condition to be true',
+	options: [
+		{
+			name: 'AND',
+			value: 'AND',
+			description: 'Only rows that meet all the conditions are selected',
+		},
+		{
+			name: 'OR',
+			value: 'OR',
+			description: 'Rows that meet at least one condition are selected',
+		},
+	],
+	default: 'AND',
+};

packages/nodes-base/nodes/MySql/v2/actions/database/Database.resource.ts

@@ -0,0 +1,76 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+import * as deleteTable from './deleteTable.operation';
+import * as executeQuery from './executeQuery.operation';
+import * as insert from './insert.operation';
+import * as select from './select.operation';
+import * as update from './update.operation';
+import * as upsert from './upsert.operation';
+import { tableRLC } from '../common.descriptions';
+
+export { deleteTable, executeQuery, insert, select, update, upsert };
+
+export const description: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		options: [
+			{
+				name: 'Delete',
+				value: 'deleteTable',
+				description: 'Delete an entire table or rows in a table',
+				action: 'Delete table or rows',
+			},
+			{
+				name: 'Execute SQL',
+				value: 'executeQuery',
+				description: 'Execute an SQL query',
+				action: 'Execute a SQL query',
+			},
+			{
+				name: 'Insert',
+				value: 'insert',
+				description: 'Insert rows in a table',
+				action: 'Insert rows in a table',
+			},
+			{
+				// eslint-disable-next-line n8n-nodes-base/node-param-option-name-wrong-for-upsert
+				name: 'Insert or Update',
+				value: 'upsert',
+				// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-upsert
+				description: 'Insert or update rows in a table',
+				action: 'Insert or update rows in a table',
+			},
+			{
+				name: 'Select',
+				value: 'select',
+				description: 'Select rows from a table',
+				action: 'Select rows from a table',
+			},
+			{
+				name: 'Update',
+				value: 'update',
+				description: 'Update rows in a table',
+				action: 'Update rows in a table',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['database'],
+			},
+		},
+		default: 'insert',
+	},
+	{
+		...tableRLC,
+		displayOptions: { hide: { operation: ['executeQuery'] } },
+	},
+	...deleteTable.description,
+	...executeQuery.description,
+	...insert.description,
+	...select.description,
+	...update.description,
+	...upsert.description,
+];

packages/nodes-base/nodes/MySql/v2/actions/database/deleteTable.operation.ts

@@ -0,0 +1,128 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeProperties } from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import { updateDisplayOptions } from '@utils/utilities';
+
+import type { QueryRunner, QueryValues, QueryWithValues } from '../../helpers/interfaces';
+import { addWhereClauses, escapeSqlIdentifier, getWhereClauses } from '../../helpers/utils';
+import {
+	optionsCollection,
+	selectRowsFixedCollection,
+	combineConditionsCollection,
+} from '../common.descriptions';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Command',
+		name: 'deleteCommand',
+		type: 'options',
+		default: 'truncate',
+		options: [
+			{
+				name: 'Truncate',
+				value: 'truncate',
+				description: "Only removes the table's data and preserves the table's structure",
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				description:
+					"Delete the rows that match the 'Select Rows' conditions below. If no selection is made, all rows in the table are deleted.",
+			},
+			{
+				name: 'Drop',
+				value: 'drop',
+				description: "Deletes the table's data and also the table's structure permanently",
+			},
+		],
+	},
+	{
+		...selectRowsFixedCollection,
+		displayOptions: {
+			show: {
+				deleteCommand: ['delete'],
+			},
+		},
+	},
+	{
+		...combineConditionsCollection,
+		displayOptions: {
+			show: {
+				deleteCommand: ['delete'],
+			},
+		},
+	},
+	optionsCollection,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['database'],
+		operation: ['deleteTable'],
+	},
+	hide: {
+		table: [''],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	inputItems: INodeExecutionData[],
+	runQueries: QueryRunner,
+): Promise<INodeExecutionData[]> {
+	let returnData: INodeExecutionData[] = [];
+
+	const queries: QueryWithValues[] = [];
+
+	for (let i = 0; i < inputItems.length; i++) {
+		const table = this.getNodeParameter('table', i, undefined, {
+			extractValue: true,
+		}) as string;
+
+		const deleteCommand = this.getNodeParameter('deleteCommand', i) as string;
+
+		let query = '';
+		let values: QueryValues = [];
+
+		if (deleteCommand === 'drop') {
+			query = `DROP TABLE IF EXISTS ${escapeSqlIdentifier(table)}`;
+		}
+
+		if (deleteCommand === 'truncate') {
+			query = `TRUNCATE TABLE ${escapeSqlIdentifier(table)}`;
+		}
+
+		if (deleteCommand === 'delete') {
+			const whereClauses = getWhereClauses(this, i);
+
+			const combineConditions = this.getNodeParameter('combineConditions', i, 'AND') as string;
+
+			[query, values] = addWhereClauses(
+				this.getNode(),
+				i,
+				`DELETE FROM ${escapeSqlIdentifier(table)}`,
+				whereClauses,
+				values,
+				combineConditions,
+			);
+		}
+
+		if (query === '') {
+			throw new NodeOperationError(
+				this.getNode(),
+				'Invalid delete command, only drop, delete and truncate are supported ',
+				{ itemIndex: i },
+			);
+		}
+
+		const queryWithValues = { query, values };
+
+		queries.push(queryWithValues);
+	}
+
+	returnData = await runQueries(queries);
+
+	return returnData;
+}

packages/nodes-base/nodes/MySql/v2/actions/database/executeQuery.operation.ts

@@ -0,0 +1,98 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import { getResolvables, updateDisplayOptions } from '@utils/utilities';
+
+import type { QueryRunner, QueryWithValues } from '../../helpers/interfaces';
+import { prepareQueryAndReplacements, replaceEmptyStringsByNulls } from '../../helpers/utils';
+import { optionsCollection } from '../common.descriptions';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Query',
+		name: 'query',
+		type: 'string',
+		default: '',
+		placeholder: 'e.g. SELECT id, name FROM product WHERE id < 40',
+		required: true,
+		description:
+			"The SQL query to execute. You can use n8n expressions and $1, $2, $3, etc to refer to the 'Query Parameters' set in options below.",
+		noDataExpression: true,
+		typeOptions: {
+			editor: 'sqlEditor',
+			sqlDialect: 'MySQL',
+		},
+		hint: 'Consider using query parameters to prevent SQL injection attacks. Add them in the options below',
+	},
+	optionsCollection,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['database'],
+		operation: ['executeQuery'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	inputItems: INodeExecutionData[],
+	runQueries: QueryRunner,
+	nodeOptions: IDataObject,
+): Promise<INodeExecutionData[]> {
+	let returnData: INodeExecutionData[] = [];
+	const items = replaceEmptyStringsByNulls(inputItems, nodeOptions.replaceEmptyStrings as boolean);
+
+	const queries: QueryWithValues[] = [];
+
+	for (let i = 0; i < items.length; i++) {
+		let rawQuery = this.getNodeParameter('query', i) as string;
+
+		for (const resolvable of getResolvables(rawQuery)) {
+			rawQuery = rawQuery.replace(resolvable, this.evaluateExpression(resolvable, i) as string);
+		}
+
+		const options = this.getNodeParameter('options', i, {});
+
+		const nodeVersion = Number(nodeOptions.nodeVersion);
+
+		let values;
+		let queryReplacement = options.queryReplacement || [];
+
+		if (typeof queryReplacement === 'string') {
+			queryReplacement = queryReplacement.split(',').map((entry) => entry.trim());
+		}
+
+		if (Array.isArray(queryReplacement)) {
+			values = queryReplacement as IDataObject[];
+		} else {
+			throw new NodeOperationError(
+				this.getNode(),
+				'Query Replacement must be a string of comma-separated values, or an array of values',
+				{ itemIndex: i },
+			);
+		}
+
+		const preparedQuery = prepareQueryAndReplacements(rawQuery, nodeVersion, values);
+
+		if ((nodeOptions.nodeVersion as number) >= 2.3) {
+			const parsedNumbers = preparedQuery.values.map((value) => {
+				return Number(value) ? Number(value) : value;
+			});
+			preparedQuery.values = parsedNumbers;
+		}
+
+		queries.push(preparedQuery);
+	}
+
+	returnData = await runQueries(queries);
+
+	return returnData;
+}

packages/nodes-base/nodes/MySql/v2/actions/database/insert.operation.ts

@@ -0,0 +1,233 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+
+import { updateDisplayOptions } from '@utils/utilities';
+
+import type {
+	QueryMode,
+	QueryRunner,
+	QueryValues,
+	QueryWithValues,
+} from '../../helpers/interfaces';
+import { AUTO_MAP, BATCH_MODE, DATA_MODE } from '../../helpers/interfaces';
+import { escapeSqlIdentifier, replaceEmptyStringsByNulls } from '../../helpers/utils';
+import { optionsCollection } from '../common.descriptions';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Data Mode',
+		name: 'dataMode',
+		type: 'options',
+		options: [
+			{
+				name: 'Auto-Map Input Data to Columns',
+				value: DATA_MODE.AUTO_MAP,
+				description: 'Use when node input properties names exactly match the table column names',
+			},
+			{
+				name: 'Map Each Column Manually',
+				value: DATA_MODE.MANUAL,
+				description: 'Set the value for each destination column manually',
+			},
+		],
+		default: AUTO_MAP,
+		description:
+			'Whether to map node input properties and the table data automatically or manually',
+	},
+	{
+		displayName: `
+		In this mode, make sure incoming data fields are named the same as the columns in your table. If needed, use an 'Edit Fields' node before this node to change the field names.
+		`,
+		name: 'notice',
+		type: 'notice',
+		default: '',
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.AUTO_MAP],
+			},
+		},
+	},
+	{
+		displayName: 'Values to Send',
+		name: 'valuesToSend',
+		placeholder: 'Add Value',
+		type: 'fixedCollection',
+		typeOptions: {
+			multipleValueButtonText: 'Add Value',
+			multipleValues: true,
+		},
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.MANUAL],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Values',
+				name: 'values',
+				values: [
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+						displayName: 'Column',
+						name: 'column',
+						type: 'options',
+						// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+						description:
+							'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+						typeOptions: {
+							loadOptionsMethod: 'getColumns',
+							loadOptionsDependsOn: ['table.value'],
+						},
+						default: [],
+					},
+					{
+						displayName: 'Value',
+						name: 'value',
+						type: 'string',
+						default: '',
+					},
+				],
+			},
+		],
+	},
+	optionsCollection,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['database'],
+		operation: ['insert'],
+	},
+	hide: {
+		table: [''],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	inputItems: INodeExecutionData[],
+	runQueries: QueryRunner,
+	nodeOptions: IDataObject,
+): Promise<INodeExecutionData[]> {
+	let returnData: INodeExecutionData[] = [];
+	const items = replaceEmptyStringsByNulls(inputItems, nodeOptions.replaceEmptyStrings as boolean);
+
+	const table = this.getNodeParameter('table', 0, '', { extractValue: true }) as string;
+
+	const dataMode = this.getNodeParameter('dataMode', 0) as string;
+	const queryBatching = (nodeOptions.queryBatching as QueryMode) || BATCH_MODE.SINGLE;
+
+	const queries: QueryWithValues[] = [];
+
+	if (queryBatching === BATCH_MODE.SINGLE) {
+		let columns: string[] = [];
+		let insertItems: IDataObject[] = [];
+
+		const priority = (nodeOptions.priority as string) || '';
+		const ignore = (nodeOptions.skipOnConflict as boolean) ? 'IGNORE' : '';
+
+		if (dataMode === DATA_MODE.AUTO_MAP) {
+			columns = [
+				...new Set(
+					items.reduce((acc, item) => {
+						const itemColumns = Object.keys(item.json);
+
+						return acc.concat(itemColumns);
+					}, [] as string[]),
+				),
+			];
+			insertItems = this.helpers.copyInputItems(items, columns);
+		}
+
+		if (dataMode === DATA_MODE.MANUAL) {
+			for (let i = 0; i < items.length; i++) {
+				const valuesToSend = (this.getNodeParameter('valuesToSend', i, []) as IDataObject)
+					.values as IDataObject[];
+
+				const item = valuesToSend.reduce((acc, { column, value }) => {
+					acc[column as string] = value;
+					return acc;
+				}, {} as IDataObject);
+
+				insertItems.push(item);
+			}
+			columns = [
+				...new Set(
+					insertItems.reduce((acc, item) => {
+						const itemColumns = Object.keys(item);
+
+						return acc.concat(itemColumns);
+					}, [] as string[]),
+				),
+			];
+		}
+
+		const escapedColumns = columns.map(escapeSqlIdentifier).join(', ');
+		const placeholder = `(${columns.map(() => '?').join(',')})`;
+		const replacements = items.map(() => placeholder).join(',');
+
+		const query = `INSERT ${priority} ${ignore} INTO ${escapeSqlIdentifier(
+			table,
+		)} (${escapedColumns}) VALUES ${replacements}`;
+
+		const values = insertItems.reduce(
+			(acc: IDataObject[], item) => acc.concat(Object.values(item) as IDataObject[]),
+			[],
+		);
+
+		queries.push({ query, values });
+	} else {
+		for (let i = 0; i < items.length; i++) {
+			let columns: string[] = [];
+			let insertItem: IDataObject = {};
+
+			const options = this.getNodeParameter('options', i);
+			const priority = (options.priority as string) || '';
+			const ignore = (options.skipOnConflict as boolean) ? 'IGNORE' : '';
+
+			if (dataMode === DATA_MODE.AUTO_MAP) {
+				columns = Object.keys(items[i].json);
+				insertItem = columns.reduce((acc, key) => {
+					if (columns.includes(key)) {
+						acc[key] = items[i].json[key];
+					}
+					return acc;
+				}, {} as IDataObject);
+			}
+
+			if (dataMode === DATA_MODE.MANUAL) {
+				const valuesToSend = (this.getNodeParameter('valuesToSend', i, []) as IDataObject)
+					.values as IDataObject[];
+
+				insertItem = valuesToSend.reduce((acc, { column, value }) => {
+					acc[column as string] = value;
+					return acc;
+				}, {} as IDataObject);
+
+				columns = Object.keys(insertItem);
+			}
+
+			const escapedColumns = columns.map(escapeSqlIdentifier).join(', ');
+			const placeholder = `(${columns.map(() => '?').join(',')})`;
+
+			const query = `INSERT ${priority} ${ignore} INTO ${escapeSqlIdentifier(
+				table,
+			)} (${escapedColumns}) VALUES ${placeholder};`;
+
+			const values = Object.values(insertItem) as QueryValues;
+
+			queries.push({ query, values });
+		}
+	}
+
+	returnData = await runQueries(queries);
+
+	return returnData;
+}

packages/nodes-base/nodes/MySql/v2/actions/database/select.operation.ts

@@ -0,0 +1,131 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+
+import { updateDisplayOptions } from '@utils/utilities';
+
+import type { QueryRunner, QueryValues, QueryWithValues, SortRule } from '../../helpers/interfaces';
+import {
+	addSortRules,
+	addWhereClauses,
+	escapeSqlIdentifier,
+	getWhereClauses,
+} from '../../helpers/utils';
+import {
+	optionsCollection,
+	sortFixedCollection,
+	selectRowsFixedCollection,
+	combineConditionsCollection,
+} from '../common.descriptions';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['event'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 50,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+		},
+		displayOptions: {
+			show: {
+				returnAll: [false],
+			},
+		},
+	},
+	selectRowsFixedCollection,
+	combineConditionsCollection,
+	sortFixedCollection,
+	optionsCollection,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['database'],
+		operation: ['select'],
+	},
+	hide: {
+		table: [''],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	inputItems: INodeExecutionData[],
+	runQueries: QueryRunner,
+): Promise<INodeExecutionData[]> {
+	let returnData: INodeExecutionData[] = [];
+
+	const queries: QueryWithValues[] = [];
+
+	for (let i = 0; i < inputItems.length; i++) {
+		const table = this.getNodeParameter('table', i, undefined, {
+			extractValue: true,
+		}) as string;
+
+		const outputColumns = this.getNodeParameter('options.outputColumns', i, ['*']) as string[];
+		const selectDistinct = this.getNodeParameter('options.selectDistinct', i, false) as boolean;
+
+		let query = '';
+		const SELECT = selectDistinct ? 'SELECT DISTINCT' : 'SELECT';
+
+		if (outputColumns.includes('*')) {
+			query = `${SELECT} * FROM ${escapeSqlIdentifier(table)}`;
+		} else {
+			const escapedColumns = outputColumns.map(escapeSqlIdentifier).join(', ');
+			query = `${SELECT} ${escapedColumns} FROM ${escapeSqlIdentifier(table)}`;
+		}
+
+		let values: QueryValues = [];
+
+		const whereClauses = getWhereClauses(this, i);
+
+		const combineConditions = this.getNodeParameter('combineConditions', i, 'AND') as string;
+
+		[query, values] = addWhereClauses(
+			this.getNode(),
+			i,
+			query,
+			whereClauses,
+			values,
+			combineConditions,
+		);
+
+		const sortRules =
+			((this.getNodeParameter('sort', i, []) as IDataObject).values as SortRule[]) || [];
+
+		[query, values] = addSortRules(query, sortRules, values);
+
+		const returnAll = this.getNodeParameter('returnAll', i, false);
+		if (!returnAll) {
+			const limit = this.getNodeParameter('limit', i, 50);
+			query += ' LIMIT ?';
+			values.push(limit);
+		}
+
+		queries.push({ query, values });
+	}
+
+	returnData = await runQueries(queries);
+
+	return returnData;
+}

packages/nodes-base/nodes/MySql/v2/actions/database/update.operation.ts

@@ -0,0 +1,201 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+
+import { updateDisplayOptions } from '@utils/utilities';
+
+import type { QueryRunner, QueryValues, QueryWithValues } from '../../helpers/interfaces';
+import { AUTO_MAP, DATA_MODE } from '../../helpers/interfaces';
+import { escapeSqlIdentifier, replaceEmptyStringsByNulls } from '../../helpers/utils';
+import { optionsCollection } from '../common.descriptions';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Data Mode',
+		name: 'dataMode',
+		type: 'options',
+		options: [
+			{
+				name: 'Auto-Map Input Data to Columns',
+				value: DATA_MODE.AUTO_MAP,
+				description: 'Use when node input properties names exactly match the table column names',
+			},
+			{
+				name: 'Map Each Column Below',
+				value: DATA_MODE.MANUAL,
+				description: 'Set the value for each destination column manually',
+			},
+		],
+		default: AUTO_MAP,
+		description:
+			'Whether to map node input properties and the table data automatically or manually',
+	},
+	{
+		displayName: `
+		In this mode, make sure incoming data fields are named the same as the columns in your table. If needed, use an 'Edit Fields' node before this node to change the field names.
+		`,
+		name: 'notice',
+		type: 'notice',
+		default: '',
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.AUTO_MAP],
+			},
+		},
+	},
+	{
+		// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+		displayName: 'Column to Match On',
+		name: 'columnToMatchOn',
+		type: 'options',
+		required: true,
+		// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+		description:
+			'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+		typeOptions: {
+			loadOptionsMethod: 'getColumns',
+			loadOptionsDependsOn: ['schema.value', 'table.value'],
+		},
+		default: '',
+		hint: "Used to find the correct row to update. Doesn't get changed.",
+	},
+	{
+		displayName: 'Value of Column to Match On',
+		name: 'valueToMatchOn',
+		type: 'string',
+		default: '',
+		description:
+			'Rows with a value in the specified "Column to Match On" that corresponds to the value in this field will be updated',
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.MANUAL],
+			},
+		},
+	},
+	{
+		displayName: 'Values to Send',
+		name: 'valuesToSend',
+		placeholder: 'Add Value',
+		type: 'fixedCollection',
+		typeOptions: {
+			multipleValueButtonText: 'Add Value',
+			multipleValues: true,
+		},
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.MANUAL],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Values',
+				name: 'values',
+				values: [
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+						displayName: 'Column',
+						name: 'column',
+						type: 'options',
+						// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+						description:
+							'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+						typeOptions: {
+							loadOptionsMethod: 'getColumnsWithoutColumnToMatchOn',
+							loadOptionsDependsOn: ['schema.value', 'table.value'],
+						},
+						default: [],
+					},
+					{
+						displayName: 'Value',
+						name: 'value',
+						type: 'string',
+						default: '',
+					},
+				],
+			},
+		],
+	},
+	optionsCollection,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['database'],
+		operation: ['update'],
+	},
+	hide: {
+		table: [''],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	inputItems: INodeExecutionData[],
+	runQueries: QueryRunner,
+	nodeOptions: IDataObject,
+): Promise<INodeExecutionData[]> {
+	let returnData: INodeExecutionData[] = [];
+	const items = replaceEmptyStringsByNulls(inputItems, nodeOptions.replaceEmptyStrings as boolean);
+
+	const queries: QueryWithValues[] = [];
+
+	for (let i = 0; i < items.length; i++) {
+		const table = this.getNodeParameter('table', i, undefined, {
+			extractValue: true,
+		}) as string;
+
+		const columnToMatchOn = this.getNodeParameter('columnToMatchOn', i) as string;
+
+		const dataMode = this.getNodeParameter('dataMode', i) as string;
+
+		let item: IDataObject = {};
+		let valueToMatchOn: string | IDataObject = '';
+
+		if (dataMode === DATA_MODE.AUTO_MAP) {
+			item = items[i].json;
+			valueToMatchOn = item[columnToMatchOn] as string;
+		}
+
+		if (dataMode === DATA_MODE.MANUAL) {
+			const valuesToSend = (this.getNodeParameter('valuesToSend', i, []) as IDataObject)
+				.values as IDataObject[];
+
+			item = valuesToSend.reduce((acc, { column, value }) => {
+				acc[column as string] = value;
+				return acc;
+			}, {} as IDataObject);
+
+			valueToMatchOn = this.getNodeParameter('valueToMatchOn', i) as string;
+		}
+
+		const values: QueryValues = [];
+
+		const updateColumns = Object.keys(item).filter((column) => column !== columnToMatchOn);
+
+		const updates: string[] = [];
+
+		for (const column of updateColumns) {
+			updates.push(`${escapeSqlIdentifier(column)} = ?`);
+			values.push(item[column] as string);
+		}
+
+		const condition = `${escapeSqlIdentifier(columnToMatchOn)} = ?`;
+		values.push(valueToMatchOn);
+
+		const query = `UPDATE ${escapeSqlIdentifier(table)} SET ${updates.join(
+			', ',
+		)} WHERE ${condition}`;
+
+		queries.push({ query, values });
+	}
+
+	returnData = await runQueries(queries);
+
+	return returnData;
+}

packages/nodes-base/nodes/MySql/v2/actions/database/upsert.operation.ts

@@ -0,0 +1,205 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+
+import { updateDisplayOptions } from '@utils/utilities';
+
+import type { QueryRunner, QueryValues, QueryWithValues } from '../../helpers/interfaces';
+import { AUTO_MAP, DATA_MODE } from '../../helpers/interfaces';
+import { escapeSqlIdentifier, replaceEmptyStringsByNulls } from '../../helpers/utils';
+import { optionsCollection } from '../common.descriptions';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Data Mode',
+		name: 'dataMode',
+		type: 'options',
+		options: [
+			{
+				name: 'Auto-Map Input Data to Columns',
+				value: DATA_MODE.AUTO_MAP,
+				description: 'Use when node input properties names exactly match the table column names',
+			},
+			{
+				name: 'Map Each Column Below',
+				value: DATA_MODE.MANUAL,
+				description: 'Set the value for each destination column manually',
+			},
+		],
+		default: AUTO_MAP,
+		description:
+			'Whether to map node input properties and the table data automatically or manually',
+	},
+	{
+		displayName: `
+		In this mode, make sure incoming data fields are named the same as the columns in your table. If needed, use an 'Edit Fields' node before this node to change the field names.
+		`,
+		name: 'notice',
+		type: 'notice',
+		default: '',
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.AUTO_MAP],
+			},
+		},
+	},
+	{
+		// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+		displayName: 'Column to Match On',
+		name: 'columnToMatchOn',
+		type: 'options',
+		required: true,
+		// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+		description:
+			'The column to compare when finding the rows to update. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>.',
+		typeOptions: {
+			loadOptionsMethod: 'getColumns',
+			loadOptionsDependsOn: ['schema.value', 'table.value'],
+		},
+		default: '',
+		hint: "Used to find the correct row to update. Doesn't get changed. Has to be unique.",
+	},
+	{
+		displayName: 'Value of Column to Match On',
+		name: 'valueToMatchOn',
+		type: 'string',
+		default: '',
+		description:
+			'Rows with a value in the specified "Column to Match On" that corresponds to the value in this field will be updated. New rows will be created for non-matching items.',
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.MANUAL],
+			},
+		},
+	},
+	{
+		displayName: 'Values to Send',
+		name: 'valuesToSend',
+		placeholder: 'Add Value',
+		type: 'fixedCollection',
+		typeOptions: {
+			multipleValueButtonText: 'Add Value',
+			multipleValues: true,
+		},
+		displayOptions: {
+			show: {
+				dataMode: [DATA_MODE.MANUAL],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Values',
+				name: 'values',
+				values: [
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+						displayName: 'Column',
+						name: 'column',
+						type: 'options',
+						// eslint-disable-next-line n8n-nodes-base/node-param-description-wrong-for-dynamic-options
+						description:
+							'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/" target="_blank">expression</a>',
+						typeOptions: {
+							loadOptionsMethod: 'getColumnsWithoutColumnToMatchOn',
+							loadOptionsDependsOn: ['schema.value', 'table.value'],
+						},
+						default: [],
+					},
+					{
+						displayName: 'Value',
+						name: 'value',
+						type: 'string',
+						default: '',
+					},
+				],
+			},
+		],
+	},
+	optionsCollection,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['database'],
+		operation: ['upsert'],
+	},
+	hide: {
+		table: [''],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	inputItems: INodeExecutionData[],
+	runQueries: QueryRunner,
+	nodeOptions: IDataObject,
+): Promise<INodeExecutionData[]> {
+	let returnData: INodeExecutionData[] = [];
+
+	const items = replaceEmptyStringsByNulls(inputItems, nodeOptions.replaceEmptyStrings as boolean);
+
+	const queries: QueryWithValues[] = [];
+
+	for (let i = 0; i < items.length; i++) {
+		const table = this.getNodeParameter('table', i, undefined, {
+			extractValue: true,
+		}) as string;
+
+		const columnToMatchOn = this.getNodeParameter('columnToMatchOn', i) as string;
+
+		const dataMode = this.getNodeParameter('dataMode', i) as string;
+
+		let item: IDataObject = {};
+
+		if (dataMode === DATA_MODE.AUTO_MAP) {
+			item = items[i].json;
+		}
+
+		if (dataMode === DATA_MODE.MANUAL) {
+			const valuesToSend = (this.getNodeParameter('valuesToSend', i, []) as IDataObject)
+				.values as IDataObject[];
+
+			item = valuesToSend.reduce((acc, { column, value }) => {
+				acc[column as string] = value;
+				return acc;
+			}, {} as IDataObject);
+
+			item[columnToMatchOn] = this.getNodeParameter('valueToMatchOn', i) as string;
+		}
+
+		const onConflict = 'ON DUPLICATE KEY UPDATE';
+
+		const columns = Object.keys(item);
+		const escapedColumns = columns.map(escapeSqlIdentifier).join(', ');
+		const placeholder = `${columns.map(() => '?').join(',')}`;
+
+		const insertQuery = `INSERT INTO ${escapeSqlIdentifier(
+			table,
+		)}(${escapedColumns}) VALUES(${placeholder})`;
+
+		const values = Object.values(item) as QueryValues;
+
+		const updateColumns = Object.keys(item).filter((column) => column !== columnToMatchOn);
+
+		const updates: string[] = [];
+
+		for (const column of updateColumns) {
+			updates.push(`${escapeSqlIdentifier(column)} = ?`);
+			values.push(item[column] as string);
+		}
+
+		const query = `${insertQuery} ${onConflict} ${updates.join(', ')}`;
+
+		queries.push({ query, values });
+	}
+
+	returnData = await runQueries(queries);
+
+	return returnData;
+}

packages/nodes-base/nodes/MySql/v2/actions/node.type.ts

@@ -0,0 +1,9 @@
+import type { AllEntities, Entity } from 'n8n-workflow';
+
+type MySQLMap = {
+	database: 'deleteTable' | 'executeQuery' | 'insert' | 'select' | 'update' | 'upsert';
+};
+
+export type MySqlType = AllEntities<MySQLMap>;
+
+export type MySQLDatabaseType = Entity<MySQLMap, 'database'>;

packages/nodes-base/nodes/MySql/v2/actions/router.ts

@@ -0,0 +1,56 @@
+import type { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import * as database from './database/Database.resource';
+import type { MySqlType } from './node.type';
+import { addExecutionHints } from '../../../../utils/utilities';
+import type { MysqlNodeCredentials, QueryRunner } from '../helpers/interfaces';
+import { configureQueryRunner } from '../helpers/utils';
+import { createPool } from '../transport';
+
+export async function router(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+	let returnData: INodeExecutionData[] = [];
+
+	const items = this.getInputData();
+	const resource = this.getNodeParameter<MySqlType>('resource', 0);
+	const operation = this.getNodeParameter('operation', 0);
+	const nodeOptions = this.getNodeParameter('options', 0);
+	const node = this.getNode();
+
+	nodeOptions.nodeVersion = node.typeVersion;
+
+	const credentials = await this.getCredentials<MysqlNodeCredentials>('mySql');
+
+	const pool = await createPool.call(this, credentials, nodeOptions);
+
+	const runQueries: QueryRunner = configureQueryRunner.call(this, nodeOptions, pool);
+
+	const mysqlNodeData = {
+		resource,
+		operation,
+	} as MySqlType;
+
+	try {
+		switch (mysqlNodeData.resource) {
+			case 'database':
+				returnData = await database[mysqlNodeData.operation].execute.call(
+					this,
+					items,
+					runQueries,
+					nodeOptions,
+				);
+				break;
+			default:
+				throw new NodeOperationError(
+					this.getNode(),
+					`The operation "${operation}" is not supported!`,
+				);
+		}
+	} finally {
+		await pool.end();
+	}
+
+	addExecutionHints(this, node, items, operation, node.executeOnce);
+
+	return [returnData];
+}

packages/nodes-base/nodes/MySql/v2/actions/versionDescription.ts

@@ -0,0 +1,43 @@
+/* eslint-disable n8n-nodes-base/node-filename-against-convention */
+import { NodeConnectionTypes, type INodeTypeDescription } from 'n8n-workflow';
+
+import * as database from './database/Database.resource';
+
+export const versionDescription: INodeTypeDescription = {
+	displayName: 'MySQL',
+	name: 'mySql',
+	icon: { light: 'file:mysql.svg', dark: 'file:mysql.dark.svg' },
+	group: ['input'],
+	version: [2, 2.1, 2.2, 2.3, 2.4, 2.5],
+	subtitle: '={{ $parameter["operation"] }}',
+	description: 'Get, add and update data in MySQL',
+	defaults: {
+		name: 'MySQL',
+	},
+	inputs: [NodeConnectionTypes.Main],
+	outputs: [NodeConnectionTypes.Main],
+	usableAsTool: true,
+	credentials: [
+		{
+			name: 'mySql',
+			required: true,
+			testedBy: 'mysqlConnectionTest',
+		},
+	],
+	properties: [
+		{
+			displayName: 'Resource',
+			name: 'resource',
+			type: 'hidden',
+			noDataExpression: true,
+			options: [
+				{
+					name: 'Database',
+					value: 'database',
+				},
+			],
+			default: 'database',
+		},
+		...database.description,
+	],
+};

packages/nodes-base/nodes/MySql/v2/helpers/interfaces.ts

@@ -0,0 +1,56 @@
+import type mysql2 from 'mysql2/promise';
+import type { IDataObject, INodeExecutionData, SSHCredentials } from 'n8n-workflow';
+
+export type Mysql2Connection = mysql2.Connection;
+export type Mysql2Pool = mysql2.Pool;
+export type Mysql2OkPacket = mysql2.OkPacket;
+export type Mysql2PoolConnection = mysql2.PoolConnection;
+
+export type QueryValues = Array<string | number | IDataObject>;
+export type QueryWithValues = { query: string; values: QueryValues };
+
+export type QueryRunner = (queries: QueryWithValues[]) => Promise<INodeExecutionData[]>;
+
+export type WhereClause = { column: string; condition: string; value: string | number };
+export type SortRule = { column: string; direction: string };
+
+export const AUTO_MAP = 'autoMapInputData';
+const MANUAL = 'defineBelow';
+export const DATA_MODE = {
+	AUTO_MAP,
+	MANUAL,
+};
+
+export const SINGLE = 'single';
+const TRANSACTION = 'transaction';
+const INDEPENDENTLY = 'independently';
+export const BATCH_MODE = { SINGLE, TRANSACTION, INDEPENDENTLY };
+
+export type QueryMode = typeof SINGLE | typeof TRANSACTION | typeof INDEPENDENTLY;
+
+type WithSSL =
+	| { ssl: false }
+	| { ssl: true; caCertificate: string; clientCertificate: string; clientPrivateKey: string };
+
+type WithSSHTunnel =
+	| { sshTunnel: false }
+	| ({
+			sshTunnel: true;
+	  } & SSHCredentials);
+
+export type MysqlNodeCredentials = {
+	host: string;
+	port: number;
+	database: string;
+	user: string;
+	password: string;
+	connectTimeout: number;
+} & WithSSL &
+	WithSSHTunnel;
+
+export type ParameterMatch = {
+	match: string;
+	index: number;
+	paramNumber: string;
+	isName: boolean;
+};

packages/nodes-base/nodes/MySql/v2/helpers/utils.ts

@@ -0,0 +1,620 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INode,
+	INodeExecutionData,
+	IPairedItemData,
+	NodeExecutionWithMetadata,
+} from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import type {
+	Mysql2Pool,
+	Mysql2PoolConnection,
+	ParameterMatch,
+	QueryMode,
+	QueryValues,
+	QueryWithValues,
+	SortRule,
+	WhereClause,
+} from './interfaces';
+import { BATCH_MODE } from './interfaces';
+import { generatePairedItemData } from '../../../../utils/utilities';
+import { operatorOptions } from '../actions/common.descriptions';
+
+export function escapeSqlIdentifier(identifier: string): string {
+	const parts = identifier.match(/(`[^`]*`|[^.`]+)/g) ?? [];
+
+	return parts
+		.map((part) => {
+			const trimmedPart = part.trim();
+
+			if (trimmedPart.startsWith('`') && trimmedPart.endsWith('`')) {
+				return trimmedPart;
+			}
+
+			return `\`${trimmedPart}\``;
+		})
+		.join('.');
+}
+
+function findParameterMatches(rawQuery: string, regex: RegExp): ParameterMatch[] {
+	const matches: ParameterMatch[] = [];
+	let match: RegExpExecArray | null;
+
+	while ((match = regex.exec(rawQuery)) !== null) {
+		matches.push({
+			match: match[0],
+			index: match.index,
+			paramNumber: match[1],
+			isName: match[0].includes(':name'),
+		});
+	}
+
+	return matches;
+}
+
+function isInsideQuotes(rawQuery: string, index: number): boolean {
+	const beforeMatch = rawQuery.substring(0, index);
+	const singleQuoteCount = (beforeMatch.match(/'/g) || []).length;
+	const doubleQuoteCount = (beforeMatch.match(/"/g) || []).length;
+	return singleQuoteCount % 2 !== 0 || doubleQuoteCount % 2 !== 0;
+}
+
+function filterValidMatches(matches: ParameterMatch[], rawQuery: string): ParameterMatch[] {
+	return matches.filter(({ index }) => !isInsideQuotes(rawQuery, index));
+}
+
+function processParameterReplacements(
+	query: string,
+	validMatches: ParameterMatch[],
+	replacements: QueryValues,
+): string {
+	let processedQuery = query;
+
+	for (const { match: matchStr, paramNumber, isName } of validMatches.reverse()) {
+		const matchIndex = Number(paramNumber) - 1;
+
+		if (matchIndex >= 0 && matchIndex < replacements.length) {
+			if (isName) {
+				processedQuery = processedQuery.replace(
+					matchStr,
+					escapeSqlIdentifier(replacements[matchIndex].toString()),
+				);
+			} else {
+				processedQuery = processedQuery.replace(matchStr, '?');
+			}
+		}
+	}
+
+	return processedQuery;
+}
+
+function extractValuesFromMatches(
+	validMatches: ParameterMatch[],
+	replacements: QueryValues,
+): QueryValues {
+	const nonNameMatches = validMatches.filter((match) => !match.isName);
+	nonNameMatches.sort((a, b) => Number(a.paramNumber) - Number(b.paramNumber));
+
+	const values: QueryValues = [];
+	for (const { paramNumber } of nonNameMatches) {
+		const matchIndex = Number(paramNumber) - 1;
+		if (matchIndex >= 0 && matchIndex < replacements.length) {
+			values.push(replacements[matchIndex]);
+		}
+	}
+
+	return values;
+}
+
+function validateReferencedParameters(
+	validMatches: ParameterMatch[],
+	replacements: QueryValues,
+): void {
+	for (const match of validMatches) {
+		const paramIndex = Number(match.paramNumber) - 1;
+		if (paramIndex >= replacements.length || paramIndex < 0) {
+			throw new Error(
+				`Parameter $${match.paramNumber} referenced in query but no replacement value provided at index ${paramIndex + 1}`,
+			);
+		}
+	}
+}
+
+export const prepareQueryAndReplacements = (
+	rawQuery: string,
+	nodeVersion: number,
+	replacements?: QueryValues,
+) => {
+	if (replacements === undefined) {
+		return { query: rawQuery, values: [] };
+	}
+
+	if (nodeVersion >= 2.5) {
+		const regex = /\$(\d+)(?::name)?/g;
+		const matches = findParameterMatches(rawQuery, regex);
+		const validMatches = filterValidMatches(matches, rawQuery);
+
+		validateReferencedParameters(validMatches, replacements);
+
+		const query = processParameterReplacements(rawQuery, validMatches, replacements);
+		const values = extractValuesFromMatches(validMatches, replacements);
+
+		return { query, values };
+	}
+
+	return prepareQueryLegacy(rawQuery, replacements);
+};
+
+export const prepareQueryLegacy = (
+	rawQuery: string,
+	replacements: QueryValues,
+): QueryWithValues => {
+	let query: string = rawQuery;
+	const values: QueryValues = [];
+
+	const regex = /\$(\d+)(?::name)?/g;
+	const matches = rawQuery.match(regex) || [];
+
+	for (const match of matches) {
+		if (match.includes(':name')) {
+			const matchIndex = Number(match.replace('$', '').replace(':name', '')) - 1;
+			query = query.replace(match, escapeSqlIdentifier(replacements[matchIndex].toString()));
+		} else {
+			const matchIndex = Number(match.replace('$', '')) - 1;
+			query = query.replace(match, '?');
+			values.push(replacements[matchIndex]);
+		}
+	}
+
+	return { query, values };
+};
+
+export function prepareErrorItem(
+	item: IDataObject,
+	error: IDataObject | NodeOperationError | Error,
+	index: number,
+) {
+	return {
+		json: { message: error.message, item: { ...item }, itemIndex: index, error: { ...error } },
+		pairedItem: { item: index },
+	} as INodeExecutionData;
+}
+
+export function parseMySqlError(
+	this: IExecuteFunctions,
+	error: any,
+	itemIndex = 0,
+	queries?: string[],
+) {
+	let message: string = error.message;
+	const description = `sql: ${error.sql}, code: ${error.code}`;
+
+	if (
+		queries?.length &&
+		(message || '').toLowerCase().includes('you have an error in your sql syntax')
+	) {
+		let queryIndex = itemIndex;
+		const failedStatement = ((message.split("near '")[1] || '').split("' at")[0] || '').split(
+			';',
+		)[0];
+
+		if (failedStatement) {
+			if (queryIndex === 0 && queries.length > 1) {
+				const failedQueryIndex = queries.findIndex((query) => query.includes(failedStatement));
+				if (failedQueryIndex !== -1) {
+					queryIndex = failedQueryIndex;
+				}
+			}
+			const lines = queries[queryIndex].split('\n');
+
+			const failedLine = lines.findIndex((line) => line.includes(failedStatement));
+			if (failedLine !== -1) {
+				message = `You have an error in your SQL syntax on line ${
+					failedLine + 1
+				} near '${failedStatement}'`;
+			}
+		}
+	}
+
+	if ((error?.message as string).includes('ECONNREFUSED')) {
+		message = 'Connection refused';
+	}
+
+	return new NodeOperationError(this.getNode(), error as Error, {
+		message,
+		description,
+		itemIndex,
+	});
+}
+
+export function wrapData(data: IDataObject | IDataObject[]): INodeExecutionData[] {
+	if (!Array.isArray(data)) {
+		return [{ json: data }];
+	}
+	return data.map((item) => ({
+		json: item,
+	}));
+}
+
+export function prepareOutput(
+	response: IDataObject[],
+	options: IDataObject,
+	statements: string[],
+	constructExecutionHelper: (
+		inputData: INodeExecutionData[],
+		options: {
+			itemData: IPairedItemData | IPairedItemData[];
+		},
+	) => NodeExecutionWithMetadata[],
+	itemData: IPairedItemData | IPairedItemData[],
+) {
+	let returnData: INodeExecutionData[] = [];
+
+	if (options.detailedOutput) {
+		response.forEach((entry, index) => {
+			const item = {
+				sql: statements[index],
+				data: entry,
+			};
+
+			const executionData = constructExecutionHelper(wrapData(item), {
+				itemData,
+			});
+
+			returnData = returnData.concat(executionData);
+		});
+	} else {
+		response
+			.filter((entry) => Array.isArray(entry))
+			.forEach((entry, index) => {
+				const executionData = constructExecutionHelper(wrapData(entry), {
+					itemData: Array.isArray(itemData) ? itemData[index] : itemData,
+				});
+
+				returnData = returnData.concat(executionData);
+			});
+	}
+
+	if (!returnData.length) {
+		if ((options?.nodeVersion as number) < 2.2) {
+			returnData.push({ json: { success: true }, pairedItem: itemData });
+		} else {
+			const isSelectQuery = statements
+				.filter((statement) => !statement.startsWith('--'))
+				.every((statement) =>
+					statement
+						.replace(/\/\*.*?\*\//g, '') // remove multiline comments
+						.replace(/\n/g, '')
+						.toLowerCase()
+						.startsWith('select'),
+				);
+
+			if (!isSelectQuery) {
+				returnData.push({ json: { success: true }, pairedItem: itemData });
+			}
+		}
+	}
+
+	return returnData;
+}
+const END_OF_STATEMENT = /;(?=(?:[^'\\]|'[^']*?'|\\[\s\S])*?$)/g;
+export const splitQueryToStatements = (query: string, filterOutEmpty = true) => {
+	const statements = query
+		.replace(/\n/g, '')
+		.split(END_OF_STATEMENT)
+		.map((statement) => statement.trim());
+	return filterOutEmpty ? statements.filter((statement) => statement !== '') : statements;
+};
+
+export function configureQueryRunner(
+	this: IExecuteFunctions,
+	options: IDataObject,
+	pool: Mysql2Pool,
+) {
+	return async (queries: QueryWithValues[]) => {
+		if (queries.length === 0) {
+			return [];
+		}
+
+		let returnData: INodeExecutionData[] = [];
+		const mode = (options.queryBatching as QueryMode) || BATCH_MODE.SINGLE;
+
+		let connection: Mysql2PoolConnection;
+		try {
+			connection = await pool.getConnection();
+		} catch (e) {
+			const error = parseMySqlError.call(this, e);
+			if (!this.continueOnFail()) {
+				throw error;
+			}
+
+			return [{ json: { message: error.message, error: { ...error } } }];
+		}
+
+		if (mode === BATCH_MODE.SINGLE) {
+			const formattedQueries = queries.map(({ query, values }) => connection.format(query, values));
+			try {
+				//releasing connection after formatting queries, otherwise pool.query() will fail with timeout
+				connection.release();
+
+				let singleQuery = '';
+				if (formattedQueries.length > 1) {
+					singleQuery = formattedQueries.map((query) => query.trim().replace(/;$/, '')).join(';');
+				} else {
+					singleQuery = formattedQueries[0];
+				}
+
+				let response: IDataObject | IDataObject[] = (
+					await pool.query(singleQuery)
+				)[0] as unknown as IDataObject;
+
+				if (!response) return [];
+
+				let statements;
+				if ((options?.nodeVersion as number) <= 2.3) {
+					statements = singleQuery
+						.replace(/\n/g, '')
+						.split(';')
+						.filter((statement) => statement !== '');
+				} else {
+					statements = splitQueryToStatements(singleQuery);
+				}
+
+				if (Array.isArray(response)) {
+					if (statements.length === 1) response = [response];
+				} else {
+					response = [response];
+				}
+
+				//because single query is used in this mode mapping itemIndex not possible, setting all items as paired
+				const pairedItem = generatePairedItemData(queries.length);
+
+				returnData = returnData.concat(
+					prepareOutput(
+						response,
+						options,
+						statements,
+						this.helpers.constructExecutionMetaData,
+						pairedItem,
+					),
+				);
+			} catch (err) {
+				const error = parseMySqlError.call(this, err, 0, formattedQueries);
+
+				if (!this.continueOnFail()) throw error;
+				returnData.push({ json: { message: error.message, error: { ...error } } });
+			}
+		} else {
+			if (mode === BATCH_MODE.INDEPENDENTLY) {
+				let formattedQuery = '';
+				for (const [index, queryWithValues] of queries.entries()) {
+					try {
+						const { query, values } = queryWithValues;
+						formattedQuery = connection.format(query, values);
+
+						let statements;
+						if ((options?.nodeVersion as number) <= 2.3) {
+							statements = formattedQuery.split(';').map((q) => q.trim());
+						} else {
+							statements = splitQueryToStatements(formattedQuery, false);
+						}
+
+						const responses: IDataObject[] = [];
+						for (const statement of statements) {
+							if (statement === '') continue;
+							const response = (await connection.query(statement))[0] as unknown as IDataObject;
+
+							responses.push(response);
+						}
+
+						returnData = returnData.concat(
+							prepareOutput(
+								responses,
+								options,
+								statements,
+								this.helpers.constructExecutionMetaData,
+								{ item: index },
+							),
+						);
+					} catch (err) {
+						const error = parseMySqlError.call(this, err, index, [formattedQuery]);
+
+						if (!this.continueOnFail()) {
+							connection.release();
+							throw error;
+						}
+						returnData.push(prepareErrorItem(queries[index], error as Error, index));
+					}
+				}
+			}
+
+			if (mode === BATCH_MODE.TRANSACTION) {
+				await connection.beginTransaction();
+
+				let formattedQuery = '';
+				for (const [index, queryWithValues] of queries.entries()) {
+					try {
+						const { query, values } = queryWithValues;
+						formattedQuery = connection.format(query, values);
+
+						let statements;
+						if ((options?.nodeVersion as number) <= 2.3) {
+							statements = formattedQuery.split(';').map((q) => q.trim());
+						} else {
+							statements = splitQueryToStatements(formattedQuery, false);
+						}
+
+						const responses: IDataObject[] = [];
+						for (const statement of statements) {
+							if (statement === '') continue;
+							const response = (await connection.query(statement))[0] as unknown as IDataObject;
+
+							responses.push(response);
+						}
+
+						returnData = returnData.concat(
+							prepareOutput(
+								responses,
+								options,
+								statements,
+								this.helpers.constructExecutionMetaData,
+								{ item: index },
+							),
+						);
+					} catch (err) {
+						const error = parseMySqlError.call(this, err, index, [formattedQuery]);
+
+						if (connection) {
+							await connection.rollback();
+							connection.release();
+						}
+
+						if (!this.continueOnFail()) throw error;
+						returnData.push(prepareErrorItem(queries[index], error as Error, index));
+
+						// Return here because we already rolled back the transaction
+						return returnData;
+					}
+				}
+
+				await connection.commit();
+			}
+
+			connection.release();
+		}
+
+		return returnData;
+	};
+}
+
+export function addWhereClauses(
+	node: INode,
+	itemIndex: number,
+	query: string,
+	clauses: WhereClause[],
+	replacements: QueryValues,
+	combineConditions?: string,
+): [string, QueryValues] {
+	if (clauses.length === 0) return [query, replacements];
+
+	let combineWith = 'AND';
+
+	if (combineConditions === 'OR') {
+		combineWith = 'OR';
+	}
+
+	let whereQuery = ' WHERE';
+	const values: QueryValues = [];
+
+	clauses.forEach((clause, index) => {
+		if (clause.condition === 'equal') {
+			clause.condition = '=';
+		}
+
+		if (['>', '<', '>=', '<='].includes(clause.condition)) {
+			const value = Number(clause.value);
+
+			if (Number.isNaN(value)) {
+				throw new NodeOperationError(
+					node,
+					`Operator in entry ${index + 1} of 'Select Rows' works with numbers, but value ${
+						clause.value
+					} is not a number`,
+					{
+						itemIndex,
+					},
+				);
+			}
+
+			clause.value = value;
+		}
+
+		let valueReplacement = ' ';
+		if (clause.condition !== 'IS NULL' && clause.condition !== 'IS NOT NULL') {
+			valueReplacement = ' ?';
+			values.push(clause.value);
+		}
+
+		const operator = index === clauses.length - 1 ? '' : ` ${combineWith}`;
+
+		whereQuery += ` ${escapeSqlIdentifier(clause.column)} ${
+			clause.condition
+		}${valueReplacement}${operator}`;
+	});
+
+	return [`${query}${whereQuery}`, replacements.concat.apply(replacements, values)];
+}
+
+export function addSortRules(
+	query: string,
+	rules: SortRule[],
+	replacements: QueryValues,
+): [string, QueryValues] {
+	if (rules.length === 0) return [query, replacements];
+
+	let orderByQuery = ' ORDER BY';
+	const values: string[] = [];
+
+	rules.forEach((rule, index) => {
+		const endWith = index === rules.length - 1 ? '' : ',';
+		const direction = rule.direction === 'ASC' ? 'ASC' : 'DESC';
+		orderByQuery += ` ${escapeSqlIdentifier(rule.column)} ${direction}${endWith}`;
+	});
+
+	return [`${query}${orderByQuery}`, replacements.concat.apply(replacements, values)];
+}
+
+export function replaceEmptyStringsByNulls(
+	items: INodeExecutionData[],
+	replace?: boolean,
+): INodeExecutionData[] {
+	if (!replace) return [...items];
+
+	const returnData: INodeExecutionData[] = items.map((item) => {
+		const newItem = { ...item };
+		const keys = Object.keys(newItem.json);
+
+		for (const key of keys) {
+			if (newItem.json[key] === '') {
+				newItem.json[key] = null;
+			}
+		}
+
+		return newItem;
+	});
+
+	return returnData;
+}
+
+// operations use 'equal' instead of '=' because of the way expressions are handled
+// manually add '=' to allow entering it instead of 'equal'
+const conditionSet = new Set(operatorOptions.map((option) => option.value)).add('=');
+
+export const isWhereClause = (clause: unknown): clause is WhereClause => {
+	if (typeof clause !== 'object' || clause === null) return false;
+	if (!('column' in clause)) return false;
+	if (
+		!('condition' in clause) ||
+		typeof clause.condition !== 'string' ||
+		!conditionSet.has(clause.condition)
+	)
+		return false;
+	return true;
+};
+
+export const getWhereClauses = (ctx: IExecuteFunctions, itemIndex: number): WhereClause[] => {
+	const whereClauses = ctx.getNodeParameter('where', itemIndex, []) as IDataObject;
+	const whereClausesValues = whereClauses.values as unknown[];
+	if (!Array.isArray(whereClausesValues)) {
+		return [];
+	}
+	const someInvalid = whereClausesValues.some((clause) => !isWhereClause(clause));
+	if (someInvalid) {
+		throw new NodeOperationError(ctx.getNode(), 'Invalid where clause', {
+			itemIndex,
+		});
+	}
+	return whereClausesValues as WhereClause[];
+};

packages/nodes-base/nodes/MySql/v2/methods/credentialTest.ts

@@ -0,0 +1,34 @@
+import type {
+	ICredentialsDecrypted,
+	ICredentialTestFunctions,
+	INodeCredentialTestResult,
+} from 'n8n-workflow';
+
+import type { MysqlNodeCredentials } from '../helpers/interfaces';
+import { createPool } from '../transport';
+
+export async function mysqlConnectionTest(
+	this: ICredentialTestFunctions,
+	credential: ICredentialsDecrypted,
+): Promise<INodeCredentialTestResult> {
+	const credentials = credential.data as MysqlNodeCredentials;
+
+	const pool = await createPool.call(this, credentials);
+
+	try {
+		const connection = await pool.getConnection();
+		connection.release();
+	} catch (error) {
+		return {
+			status: 'Error',
+			message: error.message,
+		};
+	} finally {
+		await pool.end();
+	}
+
+	return {
+		status: 'OK',
+		message: 'Connection successful!',
+	};
+}

packages/nodes-base/nodes/MySql/v2/methods/index.ts

@@ -0,0 +1,3 @@
+export * as credentialTest from './credentialTest';
+export * as listSearch from './listSearch';
+export * as loadOptions from './loadOptions';

packages/nodes-base/nodes/MySql/v2/methods/listSearch.ts

@@ -0,0 +1,34 @@
+import type { IDataObject, ILoadOptionsFunctions, INodeListSearchResult } from 'n8n-workflow';
+
+import type { MysqlNodeCredentials } from '../helpers/interfaces';
+import { createPool } from '../transport';
+
+export async function searchTables(this: ILoadOptionsFunctions): Promise<INodeListSearchResult> {
+	const credentials = await this.getCredentials<MysqlNodeCredentials>('mySql');
+
+	const nodeOptions = this.getNodeParameter('options', 0) as IDataObject;
+
+	const pool = await createPool.call(this, credentials, nodeOptions);
+
+	try {
+		const connection = await pool.getConnection();
+
+		const query = 'SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = ?';
+		const values = [credentials.database];
+
+		const formatedQuery = connection.format(query, values);
+
+		const response = (await connection.query(formatedQuery))[0];
+
+		connection.release();
+
+		const results = (response as IDataObject[]).map((table) => ({
+			name: (table.table_name as string) || (table.TABLE_NAME as string),
+			value: (table.table_name as string) || (table.TABLE_NAME as string),
+		}));
+
+		return { results };
+	} finally {
+		await pool.end();
+	}
+}

packages/nodes-base/nodes/MySql/v2/methods/loadOptions.ts

@@ -0,0 +1,57 @@
+import type { IDataObject, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+
+import type { MysqlNodeCredentials } from '../helpers/interfaces';
+import { escapeSqlIdentifier } from '../helpers/utils';
+import { createPool } from '../transport';
+
+export async function getColumns(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+	const credentials = await this.getCredentials<MysqlNodeCredentials>('mySql');
+	const nodeOptions = this.getNodeParameter('options', 0) as IDataObject;
+
+	const pool = await createPool.call(this, credentials, nodeOptions);
+
+	try {
+		const connection = await pool.getConnection();
+
+		const table = this.getNodeParameter('table', 0, {
+			extractValue: true,
+		}) as string;
+
+		const columns = (
+			await connection.query(
+				`SHOW COLUMNS FROM ${escapeSqlIdentifier(table)} FROM ${escapeSqlIdentifier(
+					credentials.database,
+				)}`,
+			)
+		)[0] as IDataObject[];
+
+		connection.release();
+
+		return (columns || []).map((column: IDataObject) => ({
+			name: column.Field as string,
+			value: column.Field as string,
+			// eslint-disable-next-line n8n-nodes-base/node-param-description-lowercase-first-char
+			description: `type: ${(column.Type as string).toUpperCase()}, nullable: ${
+				column.Null as string
+			}`,
+		}));
+	} finally {
+		await pool.end();
+	}
+}
+
+export async function getColumnsMultiOptions(
+	this: ILoadOptionsFunctions,
+): Promise<INodePropertyOptions[]> {
+	const returnData = await getColumns.call(this);
+	const returnAll = { name: '*', value: '*', description: 'All columns' };
+	return [returnAll, ...returnData];
+}
+
+export async function getColumnsWithoutColumnToMatchOn(
+	this: ILoadOptionsFunctions,
+): Promise<INodePropertyOptions[]> {
+	const columnToMatchOn = this.getNodeParameter('columnToMatchOn') as string;
+	const returnData = await getColumns.call(this);
+	return returnData.filter((column) => column.value !== columnToMatchOn);
+}

packages/nodes-base/nodes/MySql/v2/transport/index.ts

@@ -0,0 +1,99 @@
+import mysql2 from 'mysql2/promise';
+import type {
+	ICredentialTestFunctions,
+	IDataObject,
+	IExecuteFunctions,
+	ILoadOptionsFunctions,
+} from 'n8n-workflow';
+import { createServer, type AddressInfo } from 'node:net';
+
+import { LOCALHOST } from '@utils/constants';
+import { formatPrivateKey } from '@utils/utilities';
+
+import type { Mysql2Pool, MysqlNodeCredentials } from '../helpers/interfaces';
+
+export async function createPool(
+	this: IExecuteFunctions | ICredentialTestFunctions | ILoadOptionsFunctions,
+	credentials: MysqlNodeCredentials,
+	options?: IDataObject,
+): Promise<Mysql2Pool> {
+	const connectionOptions: mysql2.ConnectionOptions = {
+		host: credentials.host,
+		port: credentials.port,
+		database: credentials.database,
+		user: credentials.user,
+		password: credentials.password,
+		multipleStatements: true,
+		supportBigNumbers: true,
+		decimalNumbers: false,
+	};
+
+	if (credentials.ssl) {
+		connectionOptions.ssl = {};
+
+		if (credentials.caCertificate) {
+			connectionOptions.ssl.ca = formatPrivateKey(credentials.caCertificate);
+		}
+
+		if (credentials.clientCertificate || credentials.clientPrivateKey) {
+			connectionOptions.ssl.cert = formatPrivateKey(credentials.clientCertificate);
+			connectionOptions.ssl.key = formatPrivateKey(credentials.clientPrivateKey);
+		}
+	}
+
+	if (options?.nodeVersion && (options.nodeVersion as number) >= 2.1) {
+		connectionOptions.dateStrings = true;
+	}
+
+	if (options?.connectionLimit) {
+		connectionOptions.connectionLimit = options.connectionLimit as number;
+	}
+
+	if (options?.connectTimeout) {
+		connectionOptions.connectTimeout = options.connectTimeout as number;
+	}
+
+	if (options?.largeNumbersOutput === 'text') {
+		connectionOptions.bigNumberStrings = true;
+	}
+
+	if (options?.decimalNumbers === true) {
+		connectionOptions.decimalNumbers = true;
+	}
+
+	if (!credentials.sshTunnel) {
+		return mysql2.createPool(connectionOptions);
+	} else {
+		if (credentials.sshAuthenticateWith === 'privateKey' && credentials.privateKey) {
+			credentials.privateKey = formatPrivateKey(credentials.privateKey);
+		}
+		const sshClient = await this.helpers.getSSHClient(credentials);
+
+		// Find a free TCP port
+		const localPort = await new Promise<number>((resolve) => {
+			const tempServer = createServer();
+			tempServer.listen(0, LOCALHOST, () => {
+				resolve((tempServer.address() as AddressInfo).port);
+				tempServer.close();
+			});
+		});
+
+		const stream = await new Promise((resolve, reject) => {
+			sshClient.forwardOut(
+				LOCALHOST,
+				localPort,
+				credentials.host,
+				credentials.port,
+				(err, clientChannel) => {
+					if (err) return reject(err);
+					resolve(clientChannel);
+				},
+			);
+		});
+
+		return mysql2.createPool({
+			...connectionOptions,
+			stream,
+		});
+	}
+}