Dynamic OData Parsing

[MgSam]

I'd like to use your great library to parse an OData expression, however from what I can tell it doesn't currently support the type of dynamic situation I'm looking at.

Essentially, I can't call ODataFilterLanguage.Parse because there is no type to parse into known at compile time. Essentially, I need to be able to pass a dictionary of names/types in and have it create an expression that will check either a dictionary of values or just check values based on their ordinal position in an array.

Background- I have a data grid whose columns are unknown at compile time (it gets bound to a DataTable at runtime). I then have a search box where I want the user to be able to type OData filters. I need to compile these filters and check them against the ItemArray of each row in the table.

An existing option is to dynamically create a type with properties for each column in the data table, use that in the Parse method, and then use the resulting expression to filter against each DataRow with its items first populating instances of the dynamic type. However, this solution isn't ideal because it would involve a lot of extra copying data around just to work with the existing API.

Please let me know if this situation makes sense or if there's a way to accomplish what I'm looking to do with the existing API. Thanks!

[alex-davies]

The library parses a string into a .NET expression. The OData configuration specifically parses a string into an Expression<Func<T, bool>>. Properties referenced the OData string are mapped to .NET property accessors on T

Its not too much of a stretch to configure it so that properties referenced in the OData string are mapped to a dictionary indexer instead of a property accessor. e.g. when parsing "Age eq 12" rather than converting it to row.Age == 12 it will convert it to row["Age"] == 12

The only issue we have with using the indexer is that expressions are picky about making sure the types are correct, and all the items returned from a dictionary will be of type Object. We can add in a hack to cast the Object to be the same type as the other side of the expression, so it would produce something more similar to ((int)row["Age"]) == 12. This works for most cases, but does break down if you dictionary contains types that differ from the usual constants, for example if row["Age"] returned a long? it would cause a cast exception when trying to convert it to an int

Have a look at https://gist.github.com/codecutout/ca2b019087f81e3e59ddf998ba095a99. This does what I mentioned above.

• Will convert OData property access into a dictionary index expression (obj["Age"] instead of obj.Age)
• Rewrite all binary expression (i.e. arithmatic and logical comparisons) so it will try and convert Object to something that can be compared

To use would be something like

var filter = new DictionaryODataFilterLanguage().Parse<Dictionary<string,object>>(someODataFilterString);
IEnumerable<Dictionary<string,object>> data = getData();
var filteredData = data.Where(filter )

[MgSam]

This works great! Thank you!

A few questions/suggestions:

• Is it possible to make the filter use a Dictionary.TryGetValue rather than using the indexer? Right now it will throw if the user specifies an invalid column name, and since the filter is being applied on every row of a DataTable, all that throwing will be quite expensive and probably lead to slow downs.
• Is it possible to optionally make the dictionary used in the filter returned by Parse use StringComparer.OrdinalIgnoreCase? I don't want comparisons to be case sensitive.
• In addition to Parse, I think TryParse and ParseOrDefault methods would be helpful so you don't have to catch exceptions if the parsing fails. This is less important than the two suggestions above, as it's probably a harder ask and I'd guess users are unlikely to ever be doing parsing repeatedly in perf critical code.

Thanks again!

[alex-davies]

I don't believe expressions can handle methods with out variables in them so you can not make an expression that uses TryGetValue. Technically the code I gave you doesn't need a dictionary, just any object with an Index property defined, you could wrap your dictionary in a custom object that implements the index property but underneath it performs a TryGetValue

The parser doesn't create the dictionary, the dictionary is created beforehand. Whenever you create the dictionary set its default comparer to StringComparer.OrdinalIgnoreCase in the constructor.

All the TryParse would do is just catch the exceptions and return false if an exception occurred, which would not be that helpful (but you could always implement it as an extension method if you want). The exceptions give a good feedback as to why the string could not be parsed, it even gives the exact string segment in the original query that caused the issue. There is lots of potential to give some meaningful feedback to the user by inspecting the error objects, which would all be hidden in a TryParse

Its a good idea to keep in mind what the parser is doing; it converts a string like "Name eq 'Alex' and Age gt 16" to row=>(string)row["Name"] == "Alex" && (int)row["Age"] > 16 the row value you pass in can be any object you want and it can implement the indexer anyway you want it to.

[MgSam]

Thanks. Stupid mistake not realizing that I am creating the dictionary implementing the comparisons. I've made a thin wrapper around Dictionary that implements the behavior I want in the indexers.

One more question- the parser is using the == operator for comparison, right? Is there any way to pass in a custom equality class? Basically, I want to use StringComparer.OrdinalIgnoreCase.Equals for comparing string values. Note, this is different from my last question as I'm now talking about the "value" part of expression rather than the "key".

[alex-davies]

Take a look at https://gist.github.com/codecutout/ca2b019087f81e3e59ddf998ba095a99

You can override the eq expression. In the above link ive overwritten it so that if the left or right operands in the equals are strings it will build the expression to call the string.Equals(left,right,StringComparison.OrginalIgnoreCase) which should handle your ignore case requirement.