Root / Assembly / ARCQuery / Class

PRich

Class

KeyValue
_DescriptionAll classes with some AgoRapide specific attributes found in assembly ARCQuery.
CompoundInvalidKeyUsed as a practical solution in order to know that a given key has been attemped parsed, but was not valid.

_Member, AssemblyName, BaseTypes, ClassType, Description
CompoundKeyA class able to expand the concept of keys.

Direct sub classes are (ordered in order of priority by Parse):
1) ForeignKey: Can find related values, like for an Order, it can find Customer.FirstName.
2) EntityMethodKey: Key able to call entity read-only methods with a TryGet with data storage signature.
3) NewKey: Creates new keys, like 'CountP' (see NewKeyCountP.)
4) -AggregateKey- TODO: Implement this.

Closely related classes (Stored inside CompoundKey as members FollowingFunctionKeys and QuantileKey) are:
1) FunctionKey: Extracts data from an already existing value like 'Created.Year()' (see FunctionKeyYear)
2) QuantileKey: Can separate entities into quantiles, like Quartiles, Quintiles or Sextiles

(See also ValueComparer which can evaluation expressions like 'WHERE Created = ThisYear')

See common parser for all compound keys (Parse-) which will always 'succeed'.

TODO: Implement ITypeDescriber? Or, difficult because needs dataStorage for parsing?

Note how compound keys (and related keys) may be chained several levels deep, like for Order 'Customer.Created.Year()' or Customer.Order.Sum(Amount).
This is reflected in Parse and FollowingFunctionKeys.



_Member, AssemblyName, ClassType, Description, LongDescription
CompoundKeyOnlyFunctionOrQuantileA compound key containing only some function keys or quantile key, like Customer.Created.Year() or Customer.OrderSum.QUARTILE.
TryGetPInternal has no specific functionality, it just calls TryGetP.

_Member, AssemblyName, BaseTypes, ClassType, Description
EntityMethodKeyKey able to call entity read-only methods with a TryGet with data storage signature.

TODO: Change name into EntityMethodKey.

This is an expandable concept, that is, you can create your own read-only TryGet entity methods, in your ApplicationSpecificCode and they will be automatically picked up by this key.

Key able to call entity methods with signature like:
bool TryGet{KeyName}(IP? dataStorage, out IP retval, out string errorResponse)
These are read only methods / read-only properties.
TODO: Rename and move class when permanent form has been decided.

See also NewKey.

_Member, AssemblyName, BaseTypes, ClassType, Description
ExtensionsContains a few general nice to have extensions methods.

TODO: If this class accumulates too many methods, consider splitting it into multiple classes in a separate folder.
TODO: For instance a TypeExtensions class and DictionaryExtensions class would be natural.
TODO: (together with maybe a StringExtensionClass)

_Member, AssemblyName, ClassType
ForeignKeyCan find related values, through compound field names, like for an Order, it can find Customer.FirstName.
Can related several steps like for Device 'Hub.Customer.Name'.

This is an not an expandable concept, that is, this class contains all the relevant functionality and you are not expected to implement anything specific in your ApplicationSpecificCode.

The related value (key as specified in ForeignField can either be an ordinary property, or a NewKey / EntityMethodKey.

Note: Remember to include the foreign-key in QueryExpressionSelect like this: "Order/SELECT CustomerId, Created, Amount/WHERE Customer.FirstName = 'John'"
If you only do
"Order/SELECT Created, Amount/WHERE Customer.FirstName = 'John'"
then the link to Customer is not available.
(For the example given it would of course have been more natural to just to like this:
"Order/WHERE Customer.FirstName = 'John'/SELECT Created, Amount"
)

_Member, AssemblyName, BaseTypes, ClassType, Description
FunctionKeyExtracts data from an already existing value like extracting Year from a DateTime in 'Created.Year()'.

This is an expandable concept, that is, you can create your own implementations of this class in your ApplicationSpecificCode.

Often the extraction is actually a simplification of the existing value, like Created.Year() which would for '2020-06-11 13:36' return '2020'.

Implementing classes in StandardAgoRapideCode:
FunctionKeyDayOfWeek
FunctionKeyMonth
FunctionKeyQuarter
FunctionKeyYear
FunctionKeyYearMonth
FunctionKeyYearQuarter

TODO: As of Jun 2020 this concept only works as last item in a CompoundKey. TODO: This means that you can not chain functions.
TODO: (but there is nothing inherently against doing this, it is just that the parsers are not sufficient advanced yet).

TODO: Add a PK field, describing the value that is returned.

It can also be said to work as a function against a value field, but with the syntax 'value.functionName()' instead of functionName(value) (the chosen syntax is not really important, but it has one real advantage, eliminating the need for using aliases to specify what the function result should be called).

(See also ValueComparer which can evaluate expressions like 'WHERE Created = ThisYear')

TODO: Conceptual difference between ValueComparer and FunctionKey (working from two different directions).
TODO: FunctionKey is necessary if you want to pivot around the value.
TODO: ValueComparer is more practical if the value can have different interpretations at the same time.
TODO: An example is ValueComparerDateTime which understands that Created can be all of TODO: ThisYear, ThisMonth, ThisWeek, InTheMorning, ThisMorning and so on.
TOOD: (It would be time consuming to write all the necessary FunctionKey implementations in order to support this. TOOO: and the query syntax would be more verbose (Created.YearNumber = ThisYear or something similar, instead of just Created = ThisYear).)

Note that the concept is inherently expandable, you can create your own sub-classes and integrate them with StandardAgoRapideCode.
Note how any ApplicationSpecificCode implementations must be added to Parsers at application startup in order for them to be recognized by TryParse.

_Member, AssemblyName, ClassType, Description, Interfaces
FunctionKeyDateFormats a date without time component. Uses format yyyy-MM-dd.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyDayOfWeekExtracts DayOfWeek from field like 'Monday', 'Tuesday' and so on.

TODO: Consider sorting issues here.
TODO: Create alternative, DayOfWeekInt or similar for integer-representation.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyIntRounds a double value to the nearest integer (uses .NET data type Int64 (long)).
(formulae used is: '(long)(dbl + .5)').

TODO: Throws exception if double value is too big. Fix this (do not return any value in such a case maybe?)

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyMonthExtracts month component from field like '2020-12-09' becoming '12'.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyQuarterExtracts quarter component from datetime field like '2020-12-09' becoming 'Q4'.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyTMBTMB = Thousands, Millions, Billions.
Formats big numbers in an easier to understand format as number of Thousands, number of Millions, number of Billions.
(Not that K har used for Thousands, like 10K = 10 Thousand).

Useful in economic reports where the magnitude of the numbers are more important than the exact numbers
(Note: Sorting on the generated values is difficult as of Jul 2020, because it is done alphabetically).

TODO: Introduce also KMGT for Kilo, Mega, Giga, Tera etc (powers of 1000), and KiMiGiTi for (powers of 1024).

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyYearExtracts Year-component from field.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyYearMonthExtracts Year + Month component from field like 2020-06.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
FunctionKeyYearQuarterExtracts Year + Quarter component from field like 2020Q1.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
NewKeyA function creating new keys (new fields) for all entity object types.
Compares roughly to the concept of Extension methods in C#.
TODO: Rename into ExtensionKey

This is an expandable concept, that is, you can create your own implementations of this class in your ApplicationSpecificCode.

Note that this concept seems to have very limited potential (as of Jun 2020).
(the concept of EntityMethodKey is probably more relevant for you to use.)

In other words, there is no point in creating new implementations of NewKey when you can instead just create a TryGet{Key}-method directly in your class which gets picked up by EntityMethodKey.
Practical example: If you have a class Customer with FirstName and LastName, do not create NewKeyName, create instead Customer.TryGetName.

There are very few implementing class in StandardAgoRapideCode:
NewKeyCountP (returns the number of properties for a given entity object),
NewKeyCountPRec (returns the number of properties for a given entity object, operates recursively),
NewKeyPropertyStream (returns the PropertyStream for the given object)

TODO: Add a PK field, describing the value that is returned.

Note that will only come into play when explicit referenced, like 'SELECT *, CountP' for calling NewKeyCountP.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
NewKeyCountPReturns the number of properties for a given entity object.

Mostly included in AgoRapide as an example of how to use NewKey.
See also NewKeyCountPRec.


_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
NewKeyCountPRecReturns the number of properties for a given entity object.
Operates recursively, that is, sums up recursively properties also for properties.

Recursive variant of NewKeyCountP.


_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
NewKeyPropertyStreamReturns the PropertyStream for the given object.

Works by calling ToPropertyStream.

WARNING: Will generate huge amount of data if called for the top-level of a typical hierarchical data storage.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QuantileKeyCan separate entities into quantiles, like Quartiles, Quintiles or Sextiles.

This is an not an expandable concept, that is, this class contains all the relevant functionality and you are not expected to implement anything specific in your ApplicationSpecificCode.

This is a one-time-use only object. It should not be reused between different API request for instance, because the first call to TryGetP caches the result (within itself) for ALL entities of given type within the data storage.

This also means that it is ESSENTIAL to use the concept of cached compound key in the C# code using this class. (the ref-parameter cachedCompoundKey to TryGetP.)
(in order to avoid all entities being evaluated every time the quantile for one entity is requested.)

Note that quantiles are calculated for alle entities, regardless of the actual selection.

_Member, AssemblyName, ClassType, Description
QueryAggregateExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionRepresents part of a query (or actually a transformation) against a given collection and the data storage from which it was taken.

A series of queries are usually chained together in a fluent fashion
for instance as an API call like:
'api/RQ/std/Order/WHERE Value > 1000 NOK/REL Customer/ORDER BY LastName, FirstName/TAKE 50/'
or as a C# expression like:
'new QueryProgress(DataStorage, Orders).Where("Value > 100").Rel(typeof(Customer)).OrderBy("LastName,FirstName").Take(50)'
(but in the latter case the standard LINQ extension in .NET will of course usually provide the same or better functionality (expect for AgoRapide unique queries like QueryExpressionRel)).

See also CompoundKey which expands the concept of keys.

The main purpose of the QueryExpression concept is to empower API users to create their own simple ad-hoc reports, without needing assistance from the API developers (that is, without any C# code having to be written or new API endpoints to be created).

The QueryExpression concept is not meant to be exhaustive with relation to relational modelling, nor is it proven formally.
This concept just takes away some (or actually rather quite a lot) of the need for 'hand-crafted' code in order to cover what are quite often very common scenarios.

More complex needs can be covered by ApplicationSpecificCode implementations of this class (see below).

Note that queries can also be embedded in a Subscription (but this only gives meaning when querying against a hierarchical object storage, see AdHocQuery).

Implementing classes in StandardAgoRapideCode:
QueryExpressionAll
QueryExpressionCache
QueryExpressionHint
QueryExpressionLimit
QueryExpressionOrderBy TODO: Create QueryThenBy or improve parser in QueryOrderBy in order to order by multiple fields
QueryExpressionPivot
QueryExpressionAggregate
QueryExpressionRel
QueryExpressionSelect
QueryExpressionShuffle
QueryExpressionSkip
QueryExpressionStrict
QueryExpressionTake
QueryExpressionWhere

TODO: Potential sub-classes to be added:
-QueryAggregate- (note similarity with QueryPivot)
-QueryUnion- (for instance like /UNION {subQuery})

Note that the concept is inherently expandable, you can create your own sub-classes and integrate them with StandardAgoRapideCode.
Note how any ApplicationSpecificCode implementations must be added to Parsers at application startup in order for them to be recognized by TryParse.

One practical application for ApplicationSpecificCode implementations of QueryExpression is hand-crafted reports, for instance a 'QueryExpressionReport042', available as for instance 'api/RQ/std/Report042'.
Another application could be hand-crafted HTML-representations of result sets.

See also CompoundKey (like ForeignKey, EntityMethodKey and NewKey),
FunctionKey,
QuantileKey and
ValueComparer.

The implementations of QueryExpression (together with the classes mentioned above) constitute building blocks which for instance an API end-user can fit together to construct reports as needed.
This compares well to monolithic report creation where elements can not be reused easily.
(it is similar to the UNIX philosophy of small utilities each performing a well defined easy-to-understand function).

_Member, AssemblyName, ClassType, Description, Interfaces
QueryExpressionAggregateAggregates over the given key like
'AGGREGATE Product'.
or
'AGGREGATE Product BY Year SUM Amount'.

See SyntaxHelp.

See also QueryExpressionPivot which aggregates over two keys (row key and column key).

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionAllRepresents all entities (Execute returns input collection).

Useful in order to get result set presented by ToHTMLSimpleSingle instead of ToHTMLSimpleSingle.

Example:
For an API call like 'yourapi.com/Customer' presentation will be done by ToHTMLSimpleSingle as default.
For an API call like 'yourapi.com/Customer/All' presentation will be done by ToHTMLSimpleSingle as default.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionAllExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionCacheDescribes if cache is to be used or not.

This is relevant for generated values (as generated by FunctionKey, NewKey and similar).
Specified through QueryExpressionCache and stored in UseCache.
Used by TryGetP.
TODO: NOT IMPLEMENTED AS OF JUN 2020
TODO: Some issues are:
TODO: 1) Impossible to store cached values back to IP sub-classes like PExact<EnumType>.
TODO: 2) Introducing IP.CanAcceptAnyValue would still defeat purpose, since 1) still holds
TODO: 3) Having a global cache would be difficult, because no key available (not possible to use object itself as key).
TODO: 4) Cache would 'poison' later queries (could introduce PCacheValue though, with DateTime created and similar metadata).

Does not affect query result (other than that data may be from cache and therefore stale).

Set to ON if caches are to be used.

See QueryExpressionWithSuggestions.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionCacheExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionHintDescribes if hints are to be generated (as query progresses) for potential new queries. Specified through QueryExpressionHint and stored in CreateHints.
Does not affect query result.

Set to OFF if hints are not needed (for instance if consumer of query is not a human). This will slightly improve performance.

See QueryExpressionWithSuggestions.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionHintExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionLimitLimits the final HTML presentation of results (limits the number of elements being presented).
Does not affect the query in itself. Used in order to avoid building huge HTML pages which will not be consumed anyway.
Specified through QueryExpressionLimit and stored in Limit.
See also QueryExpressionTake which takes a specific number of elements from the current query result.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionLimitExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionOrderBySee -syntaxHelp-.

TODO: Implement also QueryThenBy and QueryThenByDescending as in ThenBy
TOOD: Syntax 'THEN BY {key} [DESC] / [ASC]'
TODO: Should probably work through casting of Details to IOrderedEnumerable.
TODO: OR, just improve parser her (multiple fields with ASC / DESC), and utilize ThenBy from within this class.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionOrderByExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionPivotCreates a table by querying over two keys like
'PIVOT Product BY Year'.
or
'PIVOT Product BY Year SUM Amount'.

See SyntaxHelp.

See also QueryExpressionAggregate which aggregates over only one key.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionPivotExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionRelEnables 'jumping' or 'travelling' from a collection of one entity type to another (related) entity type.

Enables queries like
'Order/WHERE Amount > 10000 EUR/REL Customer/REL SupportTicket'
which will show support tickets for all customer who at some time have ordered something for at least 10 000 EUR.

Corresponds coarsely to the JOIN concept in SQL

There are two ways for this to happen:

1) TODO: Give this a formal name (some type of JOIN?)
If IPRelationsKeysPointingTo has a link for the current entity type, like 'Customer' having a link to 'Order' and 'SupportTicket' then a jump from a collection of Customers can be made to for instance an Order collection by iterating through all Orders with OrderP.CustomerId present in the collection of Customers.

2) TODO: Give this a formal name (some type of JOIN?)
A jump from a collection of 'Order' or 'SupportTicket' to 'Customer' can be made by iterating through the whole collection looking for 'CustomerId = xxx' properties.

Variant 1) will be the default attempted. If not, then variant 2) will be attempted.

NOTE: The relevant keys for 'jumping' must exist. If you for instance do like this (admittedly meaningless query, but it explains the point though):
NOTE: 'Order/WHERE Amount > 10000 EUR/SELECT Amount, Created/REL Customer'
NOTE: then the key CustomerId is not available, and the jumping breaks down.
NOTE: 'Order/WHERE Amount > 10000 EUR/SELECT CustomerId, Amount, Created/REL Customer'
NOTE: on the other hand would work (but use of SELECT is meaningless anyway of course).

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionRelExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionSelectSelects which fields to include.

Note that only 'SELECT *' is not relevant (but still possible) because initially all queries start with a collection in which all fields are included.
(in other words, use of QueryExpressionSelect is only relevant in cases where you want to filter out some fields, not add fields).

'SELECT *' is relevant in connection with NewKey, like 'SELECT *, CountP' which will select all fields in addition to a new field calculated by NewKeyCountP.

Note: As of Jun 2020 will not preserve type of key, all keys in result becomes IKString

TODO: Add some functionality recognizing PriorityOrder, like
TODO: only 'SELECT' which could select only from Important or lesser value.
TODO: Or 'SELECT WHERE PriorityOrder LEQ Important' (Using negative values for PriorityOrder is not very intuitive here).
TODO: or any other query against the property keys for the relevant entity class.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionShuffleShuffles collection in random order. Useful when you want to see a limited but still 'representative' sample of result set.

Useful in collection with QueryExpressionTake.

Note extension method Shuffle which can be used in C# directly.
See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionShuffleExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionSkipSkips the specified number of elements from the current query result.

Useful in combination with QueryExpressionTake.r
See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionSkipExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionStrictDescribes level of -Strictness- when executing query. Specified through QueryExpressionStrict and stored in CurrentStrictness.
Does not affect query result, only whether query will terminate or not due to perceived inconsistencies in the data.

A typical example where you may want to set 'STRICT OFF' is when you have queries results where sometimes a specific field is not set, and that field is used in a subsequent query expression, for instance 'WHERE' or 'ORDER BY'.
This is because -QueryExpression does not have any concept of schema / 'supposed to exist' fields, it only sees the actual data.
Example: If you have this:
Customer/42/FirstName = John
Customer/42/LastName = Smith
Customer/43/FirstName = Ann
Then the query "Customer/WHERE FirstName = 'Ann'/ORDER BY LastName'"
will fail because QueryExpressionOrderBy will not see any field 'LastName'.
This query
"Customer/WHERE FirstName = 'Ann'/STRICT OFF/ORDER BY LastName'"
on the other hand will succeed.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionStrictExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionTakeTakes a specific number of elements from the current query result.

See also QueryExpressionLimit which limits the final HTML presentation of results.

Useful in combination with either QueryExpressionSkip or QueryExpressionShuffle.

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionWhereExecutes a 'WHERE {key} {operator} {value}' against the given collection.

Understands use of ValueComparer like ValueComparerDateTime

TODO: Expand syntax, in order to support AND and OR.

TODO: Allow IS NULL and IS NOT NULL in addition to EQ NULL and NEQ NULL

See SyntaxHelp.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
QueryExpressionWhereExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryExpressionWithSuggestionsKeeps track as each query item gets executed.

TODO: Find better name for this class.

Contains the original query (QueryExpression) and suggestions for potential new queries.

Next and Previous are the suggestions for potential new queries.

Generated by methods implementing Execute.

An example is QueryExpressionSkip, if it sees QueryExpressionTake as next query to be executed then it knows how many more or less to skip.

This class is not immutable (because of -ResultCount-).

_Member, AssemblyName, ClassType, Description
QueryProgressKeeps track of progress of query, and the interim result.

TODO: Rename into Query and QueryProgressDetails into QueryProgress


_Member, AssemblyName, ClassType, Description
QueryProgressDetailsKeeps track of execution of query, and also stores final result.

TODO: Rename into QueryProgress (after QueryProgress has been renamed into Query)

Necessary in order for storing final result because a query result:
1) Is a uniform collection (of identical type), and
2) Has a 'location' URL-wise that is very difficult to generate relative links for.
Therefore, the standared ToHTMLSimpleSingle method is not very well suited.

Recognized for instance by RQController in ARAAPI.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
QuerySelectExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
QueryTakeExtensionEnables fluent interface through method chaining

_Member, AssemblyName, ClassType, Description
ValueComparerCan evaluation expressions like 'WHERE Created = ThisYear.

Simplifies query expression regarding to the actual value comparision.
An example is 'Order/WHERE Created = ThisYear' as offered by ValueComparerDateTime.

Implementing classes:
ValueComparerDateTime.

TODO: Make extensible somehow.
TODO: See for instance how QueryExpression and FunctionKey has been made extensible.
TODO: (note that exact same approach can not be used for ValueComparer TODO: because there is no single word in the start identifying which parser to use.


_Member, AssemblyName, ClassType, Description, Interfaces
ValueComparerDateTimeValueComparerDateTime is an attempt at offering a human language interface for date and time queries.

This class understands such terms as Today, BeforeYesterday, LastTwoDays, Last6Months, ThisYear, LastYear and so on.

Enables queries like 'Order/WHERE Created = ThisMonth', that is, a query where you do not have to change the condition of the query expression as time passes.

Understood by QueryExpressionWhere.

Terms like Ago and In means that specific period. For instance on Thursday TwoDaysAgo means Tuesday (only) while InTwoDays means Saturday (only).

Terms like Last and Next means an interval (until today or from today). For instance on Thursday LastTwoDays means Tuesday and Wednesday while NextTwoDays means Friday and Saturday.
(see IsInterval.)

See also IsAfter, IsBefore, IsGliding.

NOTE: As soon as an instance of ValueComparerDateTime is created in C#, NOTE: it has a limited usefulness as time passes because the
NOTE: time of initialization decides the time range (StartPeriod / EndPeriod) that it compares against.
NOTE: For instance, at time 09:59 NextHour would mean 10:00 to 11:00, but the same object used later
NOTE: at 10:01 for instance would still compare against 10:00 to to 11:00.
NOTE: In other words, these object instances are one-time-use only.


_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces

56 items


Generated 2020-10-13 11:11:09.513 UTC