Fix #5547: LINQ Dictionary.Any() generates correct SQL with OBJECTTOARRAY

Co-authored-by: Copilot Autofix powered by GitHub Advanced Security <copilot-autofix-noreply@github.com>

Author: kirankumarkolli

Microsoft.Azure.Cosmos/src/Linq/ExpressionToSQL.cs

@@ -1133,7 +1133,26 @@ private static Collection VisitMemberAccessCollectionExpression(Expression input
             SqlScalarExpression body = ExpressionToSql.VisitNonSubqueryScalarExpression(inputExpression, context);
             Type type = inputExpression.Type;
 
-            Collection collection = ExpressionToSql.ConvertToCollection(body);
+            Collection collection;
+            if (type.IsDictionary())
+            {
+                // For Dictionary types, wrap with OBJECTTOARRAY to convert the object to an iterable array
+                SqlScalarExpression objectToArrayCall = SqlFunctionCallScalarExpression.CreateBuiltin(
+                    SqlFunctionCallScalarExpression.Names.ObjectToArray,
+                    body);
+
+                // Create a subquery: SELECT VALUE OBJECTTOARRAY(...)
+                SqlSelectSpec selectSpec = SqlSelectValueSpec.Create(objectToArrayCall);
+                SqlSelectClause selectClause = SqlSelectClause.Create(selectSpec);
+                SqlQuery subquery = SqlQuery.Create(selectClause, fromClause: null, whereClause: null, groupByClause: null, orderByClause: null, offsetLimitClause: null);
+                SqlCollection subqueryCollection = SqlSubqueryCollection.Create(subquery);
+                collection = new Collection(subqueryCollection);
+            }
+            else
+            {
+                collection = ExpressionToSql.ConvertToCollection(body);
+            }
+
             context.PushCollection(collection);
             ParameterExpression parameter = context.GenerateFreshParameter(type, parameterName);
             context.PushParameter(parameter, context.CurrentSubqueryBinding.ShouldBeOnNewQuery);

Microsoft.Azure.Cosmos/src/Linq/TypeSystem.cs

@@ -123,6 +123,22 @@ public static bool IsNullable(this Type type)
             return type.IsGenericType() && type.GetGenericTypeDefinition() == typeof(Nullable<>);
         }
 
+        public static bool IsDictionary(this Type type)
+        {
+            if (type.IsGenericType())
+            {
+                Type genericTypeDefinition = type.GetGenericTypeDefinition();
+                if (genericTypeDefinition == typeof(Dictionary<,>) || genericTypeDefinition == typeof(IDictionary<,>))
+                {
+                    return true;
+                }
+            }
+
+            return type.GetInterfaces().Any(interfaceType =>
+                interfaceType.IsGenericType() &&
+                interfaceType.GetGenericTypeDefinition() == typeof(IDictionary<,>));
+        }
+
         public static Type NullableUnderlyingType(this Type type)
         {
             if (type.IsNullable())

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/Linq/LinqDictionaryQueryTests.cs

@@ -0,0 +1,62 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos.Linq
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    /// <summary>
+    /// Tests for GitHub Issue #5547: 
+    /// LINQ queries using .Any() on Dictionary&lt;string, object&gt; properties should generate SQL using OBJECTTOARRAY.
+    /// </summary>
+    [TestClass]
+    public class LinqDictionaryQueryTests
+    {
+        /// <summary>
+        /// Test that IsDictionary correctly identifies Dictionary types.
+        /// </summary>
+        [TestMethod]
+        public void IsDictionary_ShouldReturnTrueForDictionaryTypes()
+        {
+            // Test Dictionary<,>
+            Assert.IsTrue(typeof(Dictionary<string, object>).IsDictionary());
+            Assert.IsTrue(typeof(Dictionary<int, string>).IsDictionary());
+            
+            // Test IDictionary<,>
+            Assert.IsTrue(typeof(IDictionary<string, object>).IsDictionary());
+            Assert.IsTrue(typeof(IDictionary<int, string>).IsDictionary());
+            
+            // Test types that implement IDictionary<,>
+            Assert.IsTrue(typeof(SortedDictionary<string, object>).IsDictionary());
+        }
+
+        /// <summary>
+        /// Test that IsDictionary correctly rejects non-Dictionary types.
+        /// </summary>
+        [TestMethod]
+        public void IsDictionary_ShouldReturnFalseForNonDictionaryTypes()
+        {
+            // Test arrays
+            Assert.IsFalse(typeof(string[]).IsDictionary());
+            Assert.IsFalse(typeof(int[]).IsDictionary());
+            
+            // Test lists
+            Assert.IsFalse(typeof(List<string>).IsDictionary());
+            Assert.IsFalse(typeof(List<object>).IsDictionary());
+            
+            // Test IEnumerable
+            Assert.IsFalse(typeof(IEnumerable<string>).IsDictionary());
+            
+            // Test primitives
+            Assert.IsFalse(typeof(string).IsDictionary());
+            Assert.IsFalse(typeof(int).IsDictionary());
+            
+            // Test other collections
+            Assert.IsFalse(typeof(HashSet<string>).IsDictionary());
+        }
+    }
+}