Query that worked in RavenDb 4.x not working in 5.x

[mmoore99]

The query shown in the code below works fine in RavenDb 4.x but does not work (returns 0 documents) in RavenDb 5.x. The 4.x and 5.x databases are identical. Any ideas why this doesn't work in 5.x?

var startDate = new DateTime(2023, 05, 01);
var endDate = new DateTime(2023, 05, 01);
var orders = _dbLocal.Query<ShopifyOrder>().Where(order => order.CreatedAt.Date >= startDate.Date && order.CreatedAt.Date <= endDate.Date).ToList();

[ayende]

What do you mean, does not work?
Wrong results? An error?

What does the RQL looks like?
Do you run on a new db or one imported from 4.x?

[mmoore99]

What do you mean, does not work?
Wrong results? An error?

The query when run under 5.x does not return any documents while the query run under 4.x does return documents. The databases are identical.

Do you run on a new db or one imported from 4.x?

The database was imported from a 4.x database

What does the RQL looks like?

How would I get the RQL?

[ayende]

RQL - look at the traffic watch.

Is this something that you can generate independently?
Is the index new on the 5.x? Is it possible that it is now indexing?

[mmoore99]

The database that is being used is a very small test database. I deleted the index and re-ran the query. The following screen shots show the status of the index that is being used. Why are there no index terms loaded for the CreatedAt.Date?

[mmoore99]

The RQL:
from 'ShopifyOrders' where created_at.Date between $p0 and $p1 {"p0":"2023-05-01T00:00:00.0000000","p1":"2023-05-01T00:00:00.0000000"}

[mmoore99]

For comparison purposes here is the index under 4.x:

[mmoore99]

I have the following initialization code in place which had to be changed in the migration to 5.x.

_documentStore.Conventions.IdentityPartsSeparator = '-';
var serializationConventions = new NewtonsoftJsonSerializationConventions
{
     CustomizeJsonSerializer = x => { x.ObjectCreationHandling = ObjectCreationHandling.Replace; },
 };
 serializationConventions.JsonContractResolver = new CustomContractResolver(serializationConventions);
 _documentStore.Conventions.Serialization = serializationConventions;

The CustomContractResolver is as follows:

public class CustomContractResolver : DefaultRavenContractResolver
    {
        public CustomContractResolver(ISerializationConventions conventions) : base(conventions)
        {
        }

        public static bool CanWrite(MemberInfo memberInfo)
        {
            switch (memberInfo)
            {
                case PropertyInfo _:
                    return ((PropertyInfo)memberInfo).CanWrite;
                case FieldInfo _:
                    return true;
            }

            throw new NotSupportedException("Cannot calculate CanWrite on " + memberInfo);
        }

        // If enabled, this code effectively causes the [JsonProperty] attribute to be ignored during serialization of specific types
        // which allow the property names for those types to be serialized using the case as in the C# object
        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            // Let the base class create all the properties. If [JsonProperty] attribute exists the name in the attribute will be assigned to the property
            var properties = base.CreateProperties(type, memberSerialization);

            if (type.FullName == typeof(ShopifyProduct).FullName 
                || (type.DeclaringType != null && type.DeclaringType.FullName == typeof(ShopifyProduct).FullName) 
                
                || type.FullName == typeof(ShopifyOrder).FullName 
                || (type.DeclaringType != null && type.DeclaringType.FullName == typeof(ShopifyOrder).FullName))
            {
                // Now inspect each property and replace the name with the C# property name which is PascalCase
                foreach (var property in properties)
                {
                    property.PropertyName = property.UnderlyingName;
                }
            }

            return properties;
        }

    }

Is this causing the auto index to be created incorrectly because the index terms are not using the correct naming? Instead of the index term being "CreatedAt" it is "created_at".

[mmoore99]

The 4.x query:
from ShopifyOrders where CreatedAt.Date between $p0 and $p1 {"p0":"2023-05-01T00:00:00.0000000","p1":"2023-05-01T00:00:00.0000000"}

The 5.x query:
from 'ShopifyOrders' where created_at.Date between $p0 and $p1 {"p0":"2023-05-01T00:00:00.0000000","p1":"2023-05-01T00:00:00.0000000"}

Note "CreatedAt.Date" versus "created_at.Date"

I assume this has to do with the CustomContractResolver discussed in the previous post but I am not sure what the problem is since it worked under 4.x. Suggestions?

[mmoore99]

Now that I know more about what has been going on I have summarized the issue under a new discussion, see #16378