Methods (SQLProvider)

Methods Module

Namespace: global
Assembly: FSharp.Data.SqlProvider.Common.dll
Parent Module: ExpressionOptimizer

Functions and values

Function or value	Description
``compareequalitywithitself`` _arg1 Full Usage: ``compareequalitywithitself`` _arg1 Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
``cutnotusedcondition`` e Full Usage: ``cutnotusedcondition`` e Parameters: e : `Expression` Returns: `Expression`	if false then x else y -> y e : `Expression` Returns: `Expression`
``evaluatebasicconstantmath`` e Full Usage: ``evaluatebasicconstantmath`` e Parameters: e : `Expression` Returns: `Expression`	Evaluate simple math between two constants. 9 * 3 --> 27 "G" + "G" --> "GG" e : `Expression` Returns: `Expression`
``evaluateconstants`` e Full Usage: ``evaluateconstants`` e Parameters: e : `Expression` Returns: `Expression`	Evaluating constants to not mess with our expressions: e : `Expression` Returns: `Expression`
``notfalseistrue`` e Full Usage: ``notfalseistrue`` e Parameters: e : `Expression` Returns: `Expression`	not(false) -> true e : `Expression` Returns: `Expression`
``optimizecomparisonranges`` exp Full Usage: ``optimizecomparisonranges`` exp Parameters: exp : `Expression` Returns: `Expression`	Optimize range/interval comparisons with proper max/min logic exp : `Expression` Returns: `Expression`
``optimizestringoperations`` _arg1 Full Usage: ``optimizestringoperations`` _arg1 Parameters: _arg1 : `Expression` Returns: `Expression`	String comparisons to IsNullOrEmpty _arg1 : `Expression` Returns: `Expression`
``removeAnonymousType`` e Full Usage: ``removeAnonymousType`` e Parameters: e : `Expression` Returns: `Expression`	Purpose of this is to replace non-used anonymous types: new AnonymousObject(Item1 = x, Item2 = "").Item1 --> x e : `Expression` Returns: `Expression`
``removeduplicatecondition`` e Full Usage: ``removeduplicatecondition`` e Parameters: e : `Expression` Returns: `Expression`	The later of two equal comparisons in one And'/Or' chain goes. Behind a short-circuit link (AndAlso, OrElse, a conditional) the right side runs only once the left side is true (false for Or'), so a comparison the left chain already holds is true (false) there. The earlier one stays, so nothing that was guarded by it runs ahead of it. Behind And/Or the right side runs regardless, and taking a comparison out of it would unguard what followed it there, so only a right side that is the comparison itself goes. e : `Expression` Returns: `Expression`
``removemutuallyexclusivecondition`` e Full Usage: ``removemutuallyexclusivecondition`` e Parameters: e : `Expression` Returns: `Expression`	e : `Expression` Returns: `Expression`
``replaceconstantcomparison`` e Full Usage: ``replaceconstantcomparison`` e Parameters: e : `Expression` Returns: `Expression`	The purpose of this is to optimize away already known constant=constant style expressions. 7 > 8 --> False "G" = "G" --> True e : `Expression` Returns: `Expression`
``simplifyarithmeticidentities`` e Full Usage: ``simplifyarithmeticidentities`` e Parameters: e : `Expression` Returns: `Expression`	Additional arithmetic identity optimizations x - 0 -> x, x - x -> 0, x % 1 -> 0 e : `Expression` Returns: `Expression`
``simplifyconditionals`` e Full Usage: ``simplifyconditionals`` e Parameters: e : `Expression` Returns: `Expression`	Simplify conditional expressions x ? true : false -> x, x ? false : true -> !x, x ? y : y -> y e : `Expression` Returns: `Expression`
``simplifystringoperations`` e Full Usage: ``simplifystringoperations`` e Parameters: e : `Expression` Returns: `Expression`	String concatenation with empty string optimization "" + x -> x, x + "" -> x Only when x cannot be null: null + "" is "" (String.Concat), while x alone stays null, so `(x + "").Length` would go from 0 to a NullReferenceException. e : `Expression` Returns: `Expression`
`absorb _arg1` Full Usage: `absorb _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`annihilate _arg1` Full Usage: `annihilate _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`associate _arg1` Full Usage: `associate _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	Not in use, would cause looping... _arg1 : `Expression` Returns: `Expression`
`associate_complement exp` Full Usage: `associate_complement exp` Parameters: exp : `Expression` Returns: `Expression`	exp : `Expression` Returns: `Expression`
`balancetree _arg1` Full Usage: `balancetree _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	Balance tree that is too much weighted to other side. The real advantage is not-so-nested-stack _arg1 : `Expression` Returns: `Expression`
`commute _arg1` Full Usage: `commute _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`commute2 _arg1` Full Usage: `commute2 _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	Not in use, would cause looping... _arg1 : `Expression` Returns: `Expression`
`commute_absorb exp` Full Usage: `commute_absorb exp` Parameters: exp : `Expression` Returns: `Expression`	exp : `Expression` Returns: `Expression`
`complement _arg1` Full Usage: `complement _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`deMorgan _arg1` Full Usage: `deMorgan _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`distribute e` Full Usage: `distribute e` Parameters: e : `Expression` Returns: `Expression`	Not in use, would cause looping... This is opposite of gather e : `Expression` Returns: `Expression`
`distribute_complement exp` Full Usage: `distribute_complement exp` Parameters: exp : `Expression` Returns: `Expression`	exp : `Expression` Returns: `Expression`
`doubleNegation _arg1` Full Usage: `doubleNegation _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`factorComplement _arg1` Full Usage: `factorComplement _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	Factorize complementary disjunctions: (X && P) \|\| (!X && P) -> P This handles the pattern where all states of a variable are covered _arg1 : `Expression` Returns: `Expression`
`gather _arg1` Full Usage: `gather _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`idempotence _arg1` Full Usage: `idempotence _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`
`identity _arg1` Full Usage: `identity _arg1` Parameters: _arg1 : `Expression` Returns: `Expression`	_arg1 : `Expression` Returns: `Expression`