EnableQueryAttribute

[cympatic]

Hi,

In the readme is clearly stated that the EnableQueryAttribute should not be used because some query options are applied twice. Is it an option to exclude all query options in the EnableQueryAttribute that are already applied by this Automapper.Extensions.OData? If so, which query options should be ignored? The question would be; which query options are applied in the Automapper.Extensions.OData.

An example of this can be found here: https://learn.microsoft.com/en-us/odata/webapi/ignore-query-option. In this example a custom EnableQueryAttribute is created with default excluding some query options.

If this would be option then the problems with the "$apply" can be solved (at least for me) because then in the OData middleware the '$apply' and, as mentioned, in the readme the applied query options would not be applied twice.

[BlaiseD]

That could work. You'll always be executing EnableQuery against the result of GetQueryAsync.

Not sure if some options are common to the apply clause and other clauses we're using.

I would inspect the tests to see the options we're using. I suspect you're looking for these:

        public ODataOptions EnableQueryFeatures(int? maxTopValue = null)
        {
            QuerySettings.EnableExpand = true;
            QuerySettings.EnableSelect = true;
            QuerySettings.EnableFilter = true;
            QuerySettings.EnableOrderBy = true;
            QuerySettings.EnableCount = true;
            QuerySettings.EnableSkipToken = true;
            SetMaxTop(maxTopValue);
            return this;
        }

The tests should also be helpful for validating your custom attribute.

[cympatic]

Yes that was where I was looking for! Then I didn't missed any of the query options that are implement in this library.

I had already created the custom EnableQueryAttribute with exactly this options in the IgnoreQueryOptions and done some tests.
My custom EnableQueryAttribe is looking like this:

public class AutomapperEnableQueryAttribute : EnableQueryAttribute
{
    public override IQueryable ApplyQuery(IQueryable queryable, ODataQueryOptions queryOptions)
    {
        var ignoreQueryOptions = 
            AllowedQueryOptions.Skip | 
            AllowedQueryOptions.Top | 
            AllowedQueryOptions.Filter | 
            AllowedQueryOptions.Expand | 
            AllowedQueryOptions.Select | 
            AllowedQueryOptions.OrderBy | 
            AllowedQueryOptions.Count;

        return queryOptions.ApplyTo(queryable, ignoreQueryOptions);
    }
}

My first impression is that is a workable option; the issues that are mentioned in the readme (some query options are applied twice) didn't occurred and the $apply is was applied. I examined the outputted query and the result, including an apply clause, was as expected. . But I've not tested it fully because of a lack of time.

Are there already unit tests in this library to unit test this? Or was the "Don't use EnableQuery" an undocumented feature 😉 and never investigated to its full extend?

[BlaiseD]

I think the existing text reflects a known issue with EnableQueryAttribute (i.e. heads-up - incorrect results if you do this) as opposed to a testable feature.

Tests are here, here and here.

Ok to PR the ReadMe to reflect How To Combine Use Enable Query with this library in place of the Do Not Use section, add tests for the how to etc.

[cympatic]

That sounds good!

I've looked at those tests and with those tests I should be able to test this, but because of a couple of travel days I have (and currently a lack of understanding how to execute the unit tests in Web.Tests).

The only consideration I had yesterday was that the fields used for the $apply should be known as database fields because the EnableQuery is building the query based on the model. But can be resolved by;

• using matching property names between model and entity (the easy/simple solution), or
• executing the query first with a ToList() (or ToListAsync if applicable) and return the list as IQueryable (this wouldn't be very efficient with a large list).

But since I'm currently not able to tests this, I'm not sure whether this could works.

However, is there anything I further can do on this?

[BlaiseD]

To run the tests just start the web projects (WebAPI.OData.EFCore and WebAPI.OData.EF6) in the solution then run the web tests. You'll have to set the checkboxes in the configuration manager - they are off by default for the CI build.

GetQueryAsync and GetQuery both return IQuerayables - already projected from the database - don't understand your concern about mapping to the database fields. Doesn't $apply work against any IQueryable?

This is an open source project - there isn't a schedule :)

[cympatic]

For example the model CoreBuilding have a property Name that is mapped to the field LongName in the entity TBuilding and the $apply=groupby((name)) is used to do a group by on property Name.

I would expect, based the column- and table mappings, a query on the database a kind of similar to this:

SELECT e.sLongName
FROM OB_Building e
GROUP BY e.sLongName

But the $apply is not aware of any these entity fields, it just have the model. My concern is whether the model property Name is mapped correctly to the database field sLongName.

Thanks for helping me out with getting those Web.Tests running. I took me a bit longer because I missed the projects MigrationTool, and SeedDatabase and I needed to update the connectionString to my own SQL Server. Now I'm able to run those tests too, I thought that I was missing SQL Server on my laptop, but that is there. Let's keep it on that it was already a long day.

WHAT?! No schedule?! No, just joking! Thanks for the understanding! I'm always on a schedule, but that's just me being impatient 😉

[BlaiseD]

Your mapping configuration should take care of the names e.g. grouping by FullName should work without FullName in the database.

    Expression<Func<IQueryable<StudentModel>, IQueryable<object>>> ex = q => q.GroupBy(a => a.FullName).Select(s => new { s.Key, Count = s.Count() });

    public class StudentModel
    {
		public string LastName { get; set; }
		public string FirstName { get; set; }
               public string FullName { get; set; }
    }

    public class Student
    {
        public string LastName { get; set; }
        public string FirstName { get; set; }
    }

SELECT ([s].[FirstName] + N' ') + [s].[LastName] AS [Key], COUNT(*) AS [Count]
FROM [Student] AS [s]
GROUP BY ([s].[FirstName] + N' ') + [s].[LastName]