From 2fd8ee4c5c0ff61f5d64a752ae3b07dccfa99b9c Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Fri, 13 Mar 2026 11:27:28 -0700 Subject: [PATCH 01/11] Add support for parsing DateTime values --- src/Core/Services/ExecutionHelper.cs | 65 ++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 79bdc6af9c..3b896ca993 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -395,9 +395,74 @@ private static bool TryGetPropertyFromParent( SupportedHotChocolateTypes.SINGLE_TYPE => value is IntValueNode intValueNode ? intValueNode.ToSingle() : ((FloatValueNode)value).ToSingle(), SupportedHotChocolateTypes.FLOAT_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDouble() : ((FloatValueNode)value).ToDouble(), SupportedHotChocolateTypes.DECIMAL_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDecimal() : ((FloatValueNode)value).ToDecimal(), + SupportedHotChocolateTypes.DATETIME_TYPE => ParseDateTimeValue(value.Value), + SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE => ParseDateTimeOffsetValue(value.Value), SupportedHotChocolateTypes.UUID_TYPE => Guid.TryParse(value.Value!.ToString(), out Guid guidValue) ? guidValue : value.Value, _ => value.Value }; + + static object? ParseDateTimeValue(object? raw) + { + if (raw is null) + { + return null; + } + + if (raw is DateTime dt) + { + return dt; + } + + if (raw is DateTimeOffset dto) + { + return dto.UtcDateTime; + } + + if (raw is string s) + { + // HotChocolate DateTime inputs are supplied as strings; parse them so DB providers + // (notably PostgreSQL) receive a typed parameter instead of text. + if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) + { + return parsedDto.UtcDateTime; + } + + if (DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTime parsedDt)) + { + return parsedDt; + } + } + + return raw; + } + + static object? ParseDateTimeOffsetValue(object? raw) + { + if (raw is null) + { + return null; + } + + if (raw is DateTimeOffset dto) + { + return dto; + } + + if (raw is DateTime dt) + { + return new DateTimeOffset(dt); + } + + if (raw is string s) + { + if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) + { + return parsedDto; + } + } + + return raw; + } } /// From 135897540a418014a0b8d67e964f67ffc62c1c62 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Tue, 21 Apr 2026 08:52:32 -0700 Subject: [PATCH 02/11] Update parsing to reflect that only support (for now) is for DATETIME_TYPE and ensure that timezone is configured to UTC for standardization --- src/Core/Resolvers/PostgreSqlExecutor.cs | 5 +++ src/Core/Services/ExecutionHelper.cs | 51 ++++++------------------ 2 files changed, 18 insertions(+), 38 deletions(-) diff --git a/src/Core/Resolvers/PostgreSqlExecutor.cs b/src/Core/Resolvers/PostgreSqlExecutor.cs index 70fa0f1079..3c525329c7 100644 --- a/src/Core/Resolvers/PostgreSqlExecutor.cs +++ b/src/Core/Resolvers/PostgreSqlExecutor.cs @@ -84,6 +84,11 @@ private void ConfigurePostgreSqlQueryExecutor() { NpgsqlConnectionStringBuilder builder = new(dataSource.ConnectionString); + if (string.IsNullOrEmpty(builder.Timezone)) + { + builder.Timezone = "UTC"; + } + if (_runtimeConfigProvider.IsLateConfigured) { builder.SslMode = SslMode.VerifyFull; diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 3b896ca993..f3d605e36c 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -63,7 +63,7 @@ public async ValueTask ExecuteQueryAsync(IMiddlewareContext context) IQueryEngine queryEngine = _queryEngineFactory.GetQueryEngine(ds.DatabaseType); IDictionary parameters = GetParametersFromContext(context); - + if (context.Selection.Type.IsListType()) { Tuple, IMetadata?> result = @@ -396,7 +396,6 @@ private static bool TryGetPropertyFromParent( SupportedHotChocolateTypes.FLOAT_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDouble() : ((FloatValueNode)value).ToDouble(), SupportedHotChocolateTypes.DECIMAL_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDecimal() : ((FloatValueNode)value).ToDecimal(), SupportedHotChocolateTypes.DATETIME_TYPE => ParseDateTimeValue(value.Value), - SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE => ParseDateTimeOffsetValue(value.Value), SupportedHotChocolateTypes.UUID_TYPE => Guid.TryParse(value.Value!.ToString(), out Guid guidValue) ? guidValue : value.Value, _ => value.Value }; @@ -410,7 +409,12 @@ private static bool TryGetPropertyFromParent( if (raw is DateTime dt) { - return dt; + return dt.Kind switch + { + DateTimeKind.Utc => dt, + DateTimeKind.Unspecified => DateTime.SpecifyKind(dt, DateTimeKind.Utc), + _ => dt.ToUniversalTime() + }; } if (raw is DateTimeOffset dto) @@ -421,44 +425,15 @@ private static bool TryGetPropertyFromParent( if (raw is string s) { // HotChocolate DateTime inputs are supplied as strings; parse them so DB providers - // (notably PostgreSQL) receive a typed parameter instead of text. - if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) + // (notably PostgreSQL) receive a typed UTC parameter instead of text. + if (DateTimeOffset.TryParse( + s, + CultureInfo.InvariantCulture, + DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, + out DateTimeOffset parsedDto)) { return parsedDto.UtcDateTime; } - - if (DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTime parsedDt)) - { - return parsedDt; - } - } - - return raw; - } - - static object? ParseDateTimeOffsetValue(object? raw) - { - if (raw is null) - { - return null; - } - - if (raw is DateTimeOffset dto) - { - return dto; - } - - if (raw is DateTime dt) - { - return new DateTimeOffset(dt); - } - - if (raw is string s) - { - if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) - { - return parsedDto; - } } return raw; From 18d4f90d8881412dc4fd25b809abac3a3e09fb12 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 22 Apr 2026 12:29:30 -0700 Subject: [PATCH 03/11] Unit tests to verify correctness --- .../UnitTests/ExecutionHelperUnitTests.cs | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs diff --git a/src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs b/src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs new file mode 100644 index 0000000000..5c1547cb25 --- /dev/null +++ b/src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs @@ -0,0 +1,60 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System; +using Azure.DataApiBuilder.Service.Services; +using HotChocolate.Execution; +using HotChocolate.Language; +using HotChocolate.Types; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; + +namespace Azure.DataApiBuilder.Service.Tests.UnitTests; + +[TestClass] +public class ExecutionHelperUnitTests +{ + [TestMethod] + public void ExtractValueFromIValueNode_DateTimeLiteral_ReturnsUtcDateTime() + { + Mock argumentSchema = CreateArgumentSchema(new DateTimeType()); + Mock variables = new(); + + object result = ExecutionHelper.ExtractValueFromIValueNode( + new StringValueNode("2026-04-22T10:15:30-07:00"), + argumentSchema.Object, + variables.Object); + + Assert.IsInstanceOfType(result); + Assert.AreEqual( + new DateTime(2026, 4, 22, 17, 15, 30, DateTimeKind.Utc), + (DateTime)result); + } + + [TestMethod] + public void ExtractValueFromIValueNode_DateTimeVariable_ReturnsUtcDateTime() + { + Mock argumentSchema = CreateArgumentSchema(new DateTimeType()); + Mock variables = new(); + variables + .Setup(v => v.GetValue("createdAt")) + .Returns(new StringValueNode("2026-04-22T10:15:30Z")); + + object result = ExecutionHelper.ExtractValueFromIValueNode( + new VariableNode("createdAt"), + argumentSchema.Object, + variables.Object); + + Assert.IsInstanceOfType(result); + Assert.AreEqual( + new DateTime(2026, 4, 22, 10, 15, 30, DateTimeKind.Utc), + (DateTime)result); + } + + private static Mock CreateArgumentSchema(IInputType type) + { + Mock argumentSchema = new(); + argumentSchema.SetupGet(a => a.Type).Returns(type); + return argumentSchema; + } +} \ No newline at end of file From ecd6403b58c2b97c22289dd485875c878abbbe50 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 22 Apr 2026 12:30:19 -0700 Subject: [PATCH 04/11] Remove unnecessary call to DateTimeStyles.AdjustToUniversal because we are anyways returning UtcDateTime --- src/Core/Services/ExecutionHelper.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index f3d605e36c..2932886966 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -429,7 +429,7 @@ private static bool TryGetPropertyFromParent( if (DateTimeOffset.TryParse( s, CultureInfo.InvariantCulture, - DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, + DateTimeStyles.AssumeUniversal, out DateTimeOffset parsedDto)) { return parsedDto.UtcDateTime; From 648b7b4e729fb38126caaf8bba7959d5798054a6 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 22 Apr 2026 14:45:43 -0700 Subject: [PATCH 05/11] Add a TODO comment to look into support for SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE --- src/Core/Services/ExecutionHelper.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 2932886966..06d92405d9 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -386,6 +386,9 @@ private static bool TryGetPropertyFromParent( return value.Value; } + // TODO: Look into why there is no support for SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE translation in argumentSchema. + // This is more of a semantic issue than a logical one because we can still do appropriate parsing even if every date/time + // (with offset or not) is treated as SupportedHotChocolateTypes.DATETIME_TYPE but it is worth looking into regardless. return argumentSchema.Type.TypeName() switch { SupportedHotChocolateTypes.BYTE_TYPE => ((IntValueNode)value).ToByte(), From 030ed45b2ce2eefeacb7af4c57b17799b4ac7d56 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Thu, 23 Apr 2026 11:21:28 -0700 Subject: [PATCH 06/11] Add integration tests to test end-to-end flow Co-authored-by: Copilot --- .../PostgreSqlGQLSupportedTypesTests.cs | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs index 8b6e399d45..aaf19246d5 100644 --- a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs +++ b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs @@ -86,6 +86,29 @@ public async Task PGSQL_real_graphql_in_filter_expectedValues( await QueryTypeColumnFilterAndOrderBy(type, "in", sqlValue, gqlValue, "IN"); } + /// + /// PostgreSQL datetime filter tests with timezone offsets. + /// Verifies that GraphQL datetime arguments are normalized to UTC before filtering. + /// + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", "=", + DisplayName = "DateTime filter eq converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "gte", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", ">=", + DisplayName = "DateTime filter gte converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T15:53:54+05:30\"", "=", + DisplayName = "DateTime filter eq converts +05:30 offset to UTC.")] + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T10:23:54Z\"", "=", + DisplayName = "DateTime filter eq preserves UTC input.")] + [DataTestMethod] + public async Task PGSQL_real_graphql_datetime_filter_offset_expectedValues( + string type, + string filterOperator, + string sqlValue, + string gqlValue, + string queryOperator) + { + await QueryTypeColumnFilterAndOrderBy(type, filterOperator, sqlValue, gqlValue, queryOperator); + } + protected override string MakeQueryOnTypeTable(List queryFields, int id) { return MakeQueryOnTypeTable(queryFields, filterValue: id.ToString(), filterField: "id"); From 80c52c541356fca1f061970d94743f49d0f5e668 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Sun, 26 Apr 2026 16:06:38 -0700 Subject: [PATCH 07/11] Remove todo comment --- src/Core/Services/ExecutionHelper.cs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 06d92405d9..2932886966 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -386,9 +386,6 @@ private static bool TryGetPropertyFromParent( return value.Value; } - // TODO: Look into why there is no support for SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE translation in argumentSchema. - // This is more of a semantic issue than a logical one because we can still do appropriate parsing even if every date/time - // (with offset or not) is treated as SupportedHotChocolateTypes.DATETIME_TYPE but it is worth looking into regardless. return argumentSchema.Type.TypeName() switch { SupportedHotChocolateTypes.BYTE_TYPE => ((IntValueNode)value).ToByte(), From 2507e0f8e25790c0584db9137d4dc6793d9566aa Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 29 Apr 2026 13:54:05 -0700 Subject: [PATCH 08/11] Added some new integration tests for DateTime GraphQL filtering Co-authored-by: Copilot --- .../PostgreSqlGQLSupportedTypesTests.cs | 125 +++++++++++++++++- 1 file changed, 120 insertions(+), 5 deletions(-) diff --git a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs index aaf19246d5..f321136362 100644 --- a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs +++ b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; +using System.Text.Json; using System.Threading.Tasks; using Microsoft.VisualStudio.TestTools.UnitTesting; using static Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes.SupportedDateTimeTypes; @@ -89,15 +90,26 @@ public async Task PGSQL_real_graphql_in_filter_expectedValues( /// /// PostgreSQL datetime filter tests with timezone offsets. /// Verifies that GraphQL datetime arguments are normalized to UTC before filtering. + /// Tests all comparison operators (eq, neq, gt, gte, lt, lte) with offset and offset-less inputs. /// [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", "=", - DisplayName = "DateTime filter eq converts -05:00 offset to UTC.")] - [DataRow(DATETIME_TYPE, "gte", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", ">=", - DisplayName = "DateTime filter gte converts -05:00 offset to UTC.")] + DisplayName = "DateTime eq converts -05:00 offset to UTC.")] [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T15:53:54+05:30\"", "=", - DisplayName = "DateTime filter eq converts +05:30 offset to UTC.")] + DisplayName = "DateTime eq converts +05:30 offset to UTC.")] [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T10:23:54Z\"", "=", - DisplayName = "DateTime filter eq preserves UTC input.")] + DisplayName = "DateTime eq preserves UTC input.")] + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T10:23:54\"", "=", + DisplayName = "DateTime eq treats offset-less input as UTC.")] + [DataRow(DATETIME_TYPE, "neq", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", "!=", + DisplayName = "DateTime neq converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "gt", "'1999-01-08 10:23:53'", "\"1999-01-08T05:23:53-05:00\"", ">", + DisplayName = "DateTime gt converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "gte", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", ">=", + DisplayName = "DateTime gte converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "lt", "'1999-01-08 10:23:55'", "\"1999-01-08T05:23:55-05:00\"", "<", + DisplayName = "DateTime lt converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "lte", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", "<=", + DisplayName = "DateTime lte converts -05:00 offset to UTC.")] [DataTestMethod] public async Task PGSQL_real_graphql_datetime_filter_offset_expectedValues( string type, @@ -109,6 +121,90 @@ public async Task PGSQL_real_graphql_datetime_filter_offset_expectedValues( await QueryTypeColumnFilterAndOrderBy(type, filterOperator, sqlValue, gqlValue, queryOperator); } + [TestMethod] + public async Task PGSQL_real_graphql_datetime_in_filter_offset_expectedValues() + { + const string field = "datetime_types"; + string gqlQuery = @"{ + supportedTypes(first: 100, orderBy: { typeid: ASC }, filter: { + " + field + @": { + in: [""1999-01-08T05:23:54-05:00"", ""1900-01-01T00:00:00Z""] + } + }) { + items { + typeid, " + field + @" + } + } + }"; + + string dbQuery = MakeQueryOnTypeTable( + queryFields: new List { new(alias: "typeid", backingColumnName: "id"), new(backingColumnName: field) }, + filterValue: "('1999-01-08 10:23:54', '1900-01-01 00:00:00')", + filterOperator: "IN", + filterField: field, + orderBy: "id", + limit: "100"); + + JsonElement actual = await ExecuteGraphQLRequestAsync(gqlQuery, "supportedTypes", isAuthenticated: false); + string expected = await GetDatabaseResultAsync(dbQuery); + + PerformTestEqualsForExtendedTypes(DATETIME_TYPE, expected, actual.GetProperty("items").ToString()); + } + + [TestMethod] + public async Task PGSQL_real_graphql_datetime_and_filter_offset_expectedValues() + { + const string field = "datetime_types"; + string gqlQuery = @"{ + supportedTypes(first: 100, orderBy: { typeid: ASC }, filter: { + and: [ + { " + field + @": { gte: ""1999-01-08T05:23:54-05:00"" } }, + { " + field + @": { lte: ""1999-01-08T05:23:54-05:00"" } } + ] + }) { + items { + typeid, " + field + @" + } + } + }"; + + string dbQuery = MakeQueryOnTypeTableWithWhereClause( + queryFields: new List { new(alias: "typeid", backingColumnName: "id"), new(backingColumnName: field) }, + whereClause: field + " >= '1999-01-08 10:23:54' AND " + field + " <= '1999-01-08 10:23:54'"); + + JsonElement actual = await ExecuteGraphQLRequestAsync(gqlQuery, "supportedTypes", isAuthenticated: false); + string expected = await GetDatabaseResultAsync(dbQuery); + + PerformTestEqualsForExtendedTypes(DATETIME_TYPE, expected, actual.GetProperty("items").ToString()); + } + + [TestMethod] + public async Task PGSQL_real_graphql_datetime_or_filter_offset_expectedValues() + { + const string field = "datetime_types"; + string gqlQuery = @"{ + supportedTypes(first: 100, orderBy: { typeid: ASC }, filter: { + or: [ + { " + field + @": { eq: ""1900-01-01T00:00:00Z"" } }, + { " + field + @": { eq: ""1999-01-08T05:23:54-05:00"" } } + ] + }) { + items { + typeid, " + field + @" + } + } + }"; + + string dbQuery = MakeQueryOnTypeTableWithWhereClause( + queryFields: new List { new(alias: "typeid", backingColumnName: "id"), new(backingColumnName: field) }, + whereClause: field + " = '1900-01-01 00:00:00' OR " + field + " = '1999-01-08 10:23:54'"); + + JsonElement actual = await ExecuteGraphQLRequestAsync(gqlQuery, "supportedTypes", isAuthenticated: false); + string expected = await GetDatabaseResultAsync(dbQuery); + + PerformTestEqualsForExtendedTypes(DATETIME_TYPE, expected, actual.GetProperty("items").ToString()); + } + protected override string MakeQueryOnTypeTable(List queryFields, int id) { return MakeQueryOnTypeTable(queryFields, filterValue: id.ToString(), filterField: "id"); @@ -165,6 +261,25 @@ private static string ProperlyFormatTypeTableColumn(string columnName) } } + private static string MakeQueryOnTypeTableWithWhereClause( + List queryFields, + string whereClause, + string orderBy = "id", + string limit = "100") + { + string formattedSelect = limit.Equals("1") ? "SELECT to_jsonb(subq3) AS DATA" : "SELECT json_agg(to_jsonb(subq3)) AS DATA"; + + return @" + " + formattedSelect + @" + FROM + (SELECT " + string.Join(", ", queryFields.Select(field => ProperlyFormatTypeTableColumn(field.BackingColumnName) + $" AS {field.Alias}")) + @" + FROM public.type_table AS table0 + WHERE " + whereClause + @" + ORDER BY " + orderBy + @" asc + LIMIT " + limit + @") AS subq3 + "; + } + /// /// Bypass DateTime GQL tests for PostreSql /// From 889b11efce9d15586631b57d7902680fd29e3b34 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 29 Apr 2026 14:22:00 -0700 Subject: [PATCH 09/11] Remove some integration tests Co-authored-by: Copilot --- .../PostgreSqlGQLSupportedTypesTests.cs | 104 ------------------ 1 file changed, 104 deletions(-) diff --git a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs index f321136362..ec091d37b0 100644 --- a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs +++ b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs @@ -3,7 +3,6 @@ using System.Collections.Generic; using System.Linq; -using System.Text.Json; using System.Threading.Tasks; using Microsoft.VisualStudio.TestTools.UnitTesting; using static Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes.SupportedDateTimeTypes; @@ -121,90 +120,6 @@ public async Task PGSQL_real_graphql_datetime_filter_offset_expectedValues( await QueryTypeColumnFilterAndOrderBy(type, filterOperator, sqlValue, gqlValue, queryOperator); } - [TestMethod] - public async Task PGSQL_real_graphql_datetime_in_filter_offset_expectedValues() - { - const string field = "datetime_types"; - string gqlQuery = @"{ - supportedTypes(first: 100, orderBy: { typeid: ASC }, filter: { - " + field + @": { - in: [""1999-01-08T05:23:54-05:00"", ""1900-01-01T00:00:00Z""] - } - }) { - items { - typeid, " + field + @" - } - } - }"; - - string dbQuery = MakeQueryOnTypeTable( - queryFields: new List { new(alias: "typeid", backingColumnName: "id"), new(backingColumnName: field) }, - filterValue: "('1999-01-08 10:23:54', '1900-01-01 00:00:00')", - filterOperator: "IN", - filterField: field, - orderBy: "id", - limit: "100"); - - JsonElement actual = await ExecuteGraphQLRequestAsync(gqlQuery, "supportedTypes", isAuthenticated: false); - string expected = await GetDatabaseResultAsync(dbQuery); - - PerformTestEqualsForExtendedTypes(DATETIME_TYPE, expected, actual.GetProperty("items").ToString()); - } - - [TestMethod] - public async Task PGSQL_real_graphql_datetime_and_filter_offset_expectedValues() - { - const string field = "datetime_types"; - string gqlQuery = @"{ - supportedTypes(first: 100, orderBy: { typeid: ASC }, filter: { - and: [ - { " + field + @": { gte: ""1999-01-08T05:23:54-05:00"" } }, - { " + field + @": { lte: ""1999-01-08T05:23:54-05:00"" } } - ] - }) { - items { - typeid, " + field + @" - } - } - }"; - - string dbQuery = MakeQueryOnTypeTableWithWhereClause( - queryFields: new List { new(alias: "typeid", backingColumnName: "id"), new(backingColumnName: field) }, - whereClause: field + " >= '1999-01-08 10:23:54' AND " + field + " <= '1999-01-08 10:23:54'"); - - JsonElement actual = await ExecuteGraphQLRequestAsync(gqlQuery, "supportedTypes", isAuthenticated: false); - string expected = await GetDatabaseResultAsync(dbQuery); - - PerformTestEqualsForExtendedTypes(DATETIME_TYPE, expected, actual.GetProperty("items").ToString()); - } - - [TestMethod] - public async Task PGSQL_real_graphql_datetime_or_filter_offset_expectedValues() - { - const string field = "datetime_types"; - string gqlQuery = @"{ - supportedTypes(first: 100, orderBy: { typeid: ASC }, filter: { - or: [ - { " + field + @": { eq: ""1900-01-01T00:00:00Z"" } }, - { " + field + @": { eq: ""1999-01-08T05:23:54-05:00"" } } - ] - }) { - items { - typeid, " + field + @" - } - } - }"; - - string dbQuery = MakeQueryOnTypeTableWithWhereClause( - queryFields: new List { new(alias: "typeid", backingColumnName: "id"), new(backingColumnName: field) }, - whereClause: field + " = '1900-01-01 00:00:00' OR " + field + " = '1999-01-08 10:23:54'"); - - JsonElement actual = await ExecuteGraphQLRequestAsync(gqlQuery, "supportedTypes", isAuthenticated: false); - string expected = await GetDatabaseResultAsync(dbQuery); - - PerformTestEqualsForExtendedTypes(DATETIME_TYPE, expected, actual.GetProperty("items").ToString()); - } - protected override string MakeQueryOnTypeTable(List queryFields, int id) { return MakeQueryOnTypeTable(queryFields, filterValue: id.ToString(), filterField: "id"); @@ -261,25 +176,6 @@ private static string ProperlyFormatTypeTableColumn(string columnName) } } - private static string MakeQueryOnTypeTableWithWhereClause( - List queryFields, - string whereClause, - string orderBy = "id", - string limit = "100") - { - string formattedSelect = limit.Equals("1") ? "SELECT to_jsonb(subq3) AS DATA" : "SELECT json_agg(to_jsonb(subq3)) AS DATA"; - - return @" - " + formattedSelect + @" - FROM - (SELECT " + string.Join(", ", queryFields.Select(field => ProperlyFormatTypeTableColumn(field.BackingColumnName) + $" AS {field.Alias}")) + @" - FROM public.type_table AS table0 - WHERE " + whereClause + @" - ORDER BY " + orderBy + @" asc - LIMIT " + limit + @") AS subq3 - "; - } - /// /// Bypass DateTime GQL tests for PostreSql /// From d62a0b8370cd0e40765ac7032cd96050db938ac7 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Sun, 3 May 2026 20:08:19 -0700 Subject: [PATCH 10/11] Fix PostgreSQL query construction in the case of no matching rows Co-authored-by: Copilot --- .../PostgreSqlGQLSupportedTypesTests.cs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs index ec091d37b0..b45e9cf5a7 100644 --- a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs +++ b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs @@ -133,7 +133,9 @@ protected override string MakeQueryOnTypeTable( string orderBy = "id", string limit = "1") { - string formattedSelect = limit.Equals("1") ? "SELECT to_jsonb(subq3) AS DATA" : "SELECT json_agg(to_jsonb(subq3)) AS DATA"; + string formattedSelect = limit.Equals("1") + ? "SELECT to_jsonb(subq3) AS DATA" + : "SELECT COALESCE(json_agg(to_jsonb(subq3)), '[]'::json) AS DATA"; return @" " + formattedSelect + @" From c2c034767a62a854f1abe898cb48118cd7d6dff9 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Sun, 3 May 2026 20:10:22 -0700 Subject: [PATCH 11/11] Prevent bypass of DateTime GQL tests for PostgreSQL --- .../PostgreSqlGQLSupportedTypesTests.cs | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs index b45e9cf5a7..de57c6c3b7 100644 --- a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs +++ b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs @@ -177,15 +177,5 @@ private static string ProperlyFormatTypeTableColumn(string columnName) return columnName; } } - - /// - /// Bypass DateTime GQL tests for PostreSql - /// - [DataTestMethod] - [Ignore] - public new void QueryTypeColumnFilterAndOrderByDateTime(string type, string filterOperator, string sqlValue, string gqlValue, string queryOperator) - { - Assert.Inconclusive("Test skipped for PostgreSql."); - } } }