SQLProvider

Methods Module

Functions and values

Function or value Description

``compareequalitywithitself`` _arg1

Full Usage: ``compareequalitywithitself`` _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

``cutnotusedcondition`` e

Full Usage: ``cutnotusedcondition`` e

Parameters:
Returns: Expression

if false then x else y -> y

e : Expression
Returns: Expression

``evaluatebasicconstantmath`` e

Full Usage: ``evaluatebasicconstantmath`` e

Parameters:
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:
Returns: Expression

Evaluating constants to not mess with our expressions:

e : Expression
Returns: Expression

``notfalseistrue`` e

Full Usage: ``notfalseistrue`` e

Parameters:
Returns: Expression

not(false) -> true

e : Expression
Returns: Expression

``optimizecomparisonranges`` exp

Full Usage: ``optimizecomparisonranges`` exp

Parameters:
Returns: Expression

Optimize range/interval comparisons with proper max/min logic

exp : Expression
Returns: Expression

``optimizestringoperations`` _arg1

Full Usage: ``optimizestringoperations`` _arg1

Parameters:
Returns: Expression

String comparisons to IsNullOrEmpty

_arg1 : Expression
Returns: Expression

``removeAnonymousType`` e

Full Usage: ``removeAnonymousType`` e

Parameters:
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:
Returns: Expression
e : Expression
Returns: Expression

``removemutuallyexclusivecondition`` e

Full Usage: ``removemutuallyexclusivecondition`` e

Parameters:
Returns: Expression
e : Expression
Returns: Expression

``replaceconstantcomparison`` e

Full Usage: ``replaceconstantcomparison`` e

Parameters:
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:
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:
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:
Returns: Expression

String concatenation with empty string optimization "" + x -> x, x + "" -> x

e : Expression
Returns: Expression

absorb _arg1

Full Usage: absorb _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

annihilate _arg1

Full Usage: annihilate _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

associate _arg1

Full Usage: associate _arg1

Parameters:
Returns: Expression

Not in use, would cause looping...

_arg1 : Expression
Returns: Expression

associate_complement exp

Full Usage: associate_complement exp

Parameters:
Returns: Expression
exp : Expression
Returns: Expression

balancetree _arg1

Full Usage: balancetree _arg1

Parameters:
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:
Returns: Expression
_arg1 : Expression
Returns: Expression

commute2 _arg1

Full Usage: commute2 _arg1

Parameters:
Returns: Expression

Not in use, would cause looping...

_arg1 : Expression
Returns: Expression

commute_absorb exp

Full Usage: commute_absorb exp

Parameters:
Returns: Expression
exp : Expression
Returns: Expression

complement _arg1

Full Usage: complement _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

deMorgan _arg1

Full Usage: deMorgan _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

distribute e

Full Usage: distribute e

Parameters:
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:
Returns: Expression
exp : Expression
Returns: Expression

doubleNegation _arg1

Full Usage: doubleNegation _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

gather _arg1

Full Usage: gather _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

idempotence _arg1

Full Usage: idempotence _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

identity _arg1

Full Usage: identity _arg1

Parameters:
Returns: Expression
_arg1 : Expression
Returns: Expression

Type something to start searching.