Add support for model based optimizing IsDistinctFrom/IsNotDistinctFrom

Change-type: minor

Author: Page-

src/AbstractSQLOptimiser.ts

@@ -586,6 +586,16 @@ const typeRules: Dictionary<MatchFn> = {
 
 			return ['NotExists', getAbstractSqlQuery(args, valueIndex)];
 		}),
+		Helper<OptimisationMatchFn>((args) => {
+			checkArgs('IsDistinctFrom', args, 2);
+			if (
+				isNotNullable(getAbstractSqlQuery(args, 0)) &&
+				isNotNullable(getAbstractSqlQuery(args, 1))
+			) {
+				return ['Equals', ...args];
+			}
+			return false;
+		}),
 		matchArgs('IsNotDistinctFrom', AnyValue, AnyValue),
 	),
 	IsDistinctFrom: tryMatches(
@@ -602,6 +612,16 @@ const typeRules: Dictionary<MatchFn> = {
 
 			return ['Exists', getAbstractSqlQuery(args, valueIndex)];
 		}),
+		Helper<OptimisationMatchFn>((args) => {
+			checkArgs('IsDistinctFrom', args, 2);
+			if (
+				isNotNullable(getAbstractSqlQuery(args, 0)) &&
+				isNotNullable(getAbstractSqlQuery(args, 1))
+			) {
+				return ['NotEquals', ...args];
+			}
+			return false;
+		}),
 		matchArgs('IsDistinctFrom', AnyValue, AnyValue),
 	),
 	Add: MathOp('Add'),

test/abstract-sql/models-based-optimizations.ts

@@ -110,3 +110,131 @@ it('should optimize NotExists for a non nullable field', () => {
 	).to.have.nested.property('rules[0].sql').that.equals(`\
 SELECT 1 AS "result";`);
 });
+
+it('should optimize IsDistinctFrom for two non nullable fields', () => {
+	expect(
+		AbstractSQLCompiler.postgres.compileSchema({
+			synonyms: {},
+			relationships: {},
+			tables: {
+				test: {
+					name: 'test',
+					resourceName: 'test',
+					idField: 'id',
+					fields: [
+						{
+							fieldName: 'id',
+							dataType: 'Integer',
+							required: true,
+							index: 'PRIMARY KEY',
+						},
+						{
+							fieldName: 'num',
+							dataType: 'Integer',
+							required: true,
+						},
+					],
+					indexes: [],
+					primitive: false,
+				},
+			},
+			rules: [
+				[
+					'Rule',
+					[
+						'Body',
+						[
+							'Not',
+							[
+								'Exists',
+								[
+									'SelectQuery',
+									['Select', []],
+									['From', ['test', 'test.0']],
+									[
+										'Where',
+										[
+											'IsDistinctFrom',
+											['ReferencedField', 'test.0', 'id'],
+											['ReferencedField', 'test.0', 'num'],
+										],
+									],
+								],
+							],
+						],
+					] as AbstractSQLCompiler.AbstractSqlQuery,
+					['StructuredEnglish', 'Test rule'],
+				],
+			],
+		}),
+	).to.have.nested.property('rules[0].sql').that.equals(`\
+SELECT NOT EXISTS (
+	SELECT 1
+	FROM "test" AS "test.0"
+	WHERE "test.0"."id" != "test.0"."num"
+) AS "result";`);
+});
+
+it('should optimize IsNotDistinctFrom for two non nullable fields', () => {
+	expect(
+		AbstractSQLCompiler.postgres.compileSchema({
+			synonyms: {},
+			relationships: {},
+			tables: {
+				test: {
+					name: 'test',
+					resourceName: 'test',
+					idField: 'id',
+					fields: [
+						{
+							fieldName: 'id',
+							dataType: 'Integer',
+							required: true,
+							index: 'PRIMARY KEY',
+						},
+						{
+							fieldName: 'num',
+							dataType: 'Integer',
+							required: true,
+						},
+					],
+					indexes: [],
+					primitive: false,
+				},
+			},
+			rules: [
+				[
+					'Rule',
+					[
+						'Body',
+						[
+							'Not',
+							[
+								'Exists',
+								[
+									'SelectQuery',
+									['Select', []],
+									['From', ['test', 'test.0']],
+									[
+										'Where',
+										[
+											'IsNotDistinctFrom',
+											['ReferencedField', 'test.0', 'id'],
+											['ReferencedField', 'test.0', 'num'],
+										],
+									],
+								],
+							],
+						],
+					] as AbstractSQLCompiler.AbstractSqlQuery,
+					['StructuredEnglish', 'Test rule'],
+				],
+			],
+		}),
+	).to.have.nested.property('rules[0].sql').that.equals(`\
+SELECT NOT EXISTS (
+	SELECT 1
+	FROM "test" AS "test.0"
+	WHERE "test.0"."id" = "test.0"."num"
+) AS "result";`);
+});