Transforming an expression tree hierarchy of a database query for dynamic data of a database

1. At least one computer-readable storage medium, excluding transitory signals and carrying instructions, which, when executed by at least one data processor, cause the data processor to:

generate an expression tree hierarchy based on a database query that refers to dynamic data of a database having a data model,

wherein the dynamic data is undefined in the data model of the database,

invoke a process that traverses the expression tree hierarchy to transform the expression tree hierarchy into another expression tree hierarchy;

iteratively or recursively translate multiple expression fragments of the expression tree hierarchy in accordance with the process while maintaining a contextual type stack,

wherein a particular iteration or recursion operates on a particular expression fragment of the multiple expression fragments to convert the particular expression fragment into another expression fragment for the other expression tree hierarchy.

2. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a lambda expression;

creating a typed lambda expression based upon one or more types that are at a top of the contextual type stack;

iteratively or recursively using the process to translate a body expression of the lambda expression; and

wrapping a new lambda expression around the translated body expression.

3. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a method call expression; and

convert a field path associated with particular dynamic data referenced by the particular fragment into a nested property expression.

4. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a method call expression;

convert a field path associated with particular dynamic data referenced by the particular fragment into a nested property expression; and

add a derived type to the contextual type stack.

5. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a method call expression;

record a size of the contextual type stack; and

translate all parameter expressions of the particular fragment expression.

6. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a LINQ-compatible method or convert a portion of the particular expression fragment into a LINQ-compatible expression;

wrap a new method call expression around parameters of the LINQ-compatible method that are translated in another iteration or recursion of the process; and

truncate the contextual types stack to match a recorded size.

7. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a binary expression;

derive a mutually common operand type from operands of the binary expression;

convert the mutually common operand type into a derived common type of the contextual types stack; and

wrap a new binary expression around the operands of the binary expression.

8. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a binary expression; and

wrap a new binary expression around operands of the binary expression.

9. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a unary expression;

translate a single operand of the unary expression; and

wrap a new unary expression around the translated single operand.

10. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a value expression;

determine that the value expression includes a static property accessor; and

convert a field path of the static property accessor to a nested property expression.

11. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a value expression;

determine that the value expression includes an accessor other than a static property accessor; and

leave the accessor unmodified.

12. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to particular dynamic data;

convert a portion of the particular dynamic data referenced by the particular expression fragment into a LINQ table value with a particular type; and

add a particular type of a LINQ table value to the contextual type stack.

13. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

determine that the particular expression fragment refers to a constant expression; and

evaluate and condense the constant expression.

14. The at least one computer-readable storage medium of claim 1 , wherein a MetaRecordSet class provides a starting point for intercepting and translating incoming expression fragments.

15. The at least one computer-readable storage medium of claim 1 , wherein the data processor is further caused to:

implement field-pathing that uses a metadata cache to facilitate arbitrary field access.

16. A method for querying dynamic data in a database, the database having a data model, the method comprising:

generating an expression tree hierarchy based on a database query that refers to dynamic data of a database having a data model,

wherein the dynamic data includes a user-defined database column or dynamic table name, and

wherein the expression tree hierarchy is based on the user-defined database column or the dynamic table name;

invoking a process that traverses the expression tree hierarchy to transform the expression tree hierarchy;

iteratively or recursively translating multiple expression fragments of the expression tree hierarchy in accordance with the process,

wherein a particular iteration or recursion operates on a particular expression fragment of the multiple expression fragments to convert the particular expression fragment into another expression fragment for another expression tree hierarchy.

17. The method of claim 16 , wherein the expression tree hierarchy is based on both the user-defined database column and the dynamic table name.

18. The method of claim 16 further comprising:

maintaining a contextual type stack during the transformation as a basis for disambiguating, in the transformation, names for database columns.

19. A computing system for querying dynamic data in a database, the database having a data model, the system comprising:

one or more data processors; and

a memory storing instructions that, when executed by the one or more data processors, cause the computing system to:

generate an expression tree hierarchy based on a database query that refers to dynamic data of a database having a data model,

invoke a process that traverses the expression tree hierarchy to transform the expression tree hierarchy into another expression tree hierarchy;

iteratively or recursively translate multiple expression fragments of the expression tree hierarchy in accordance with the process,

wherein a particular iteration or recursion operates on a particular expression fragment of the multiple expression fragments to convert the particular expression fragment into another expression fragment for the other expression tree hierarchy.

20. The system of claim 19 , wherein the process commences at a root node of the expression tree hierarchy.