Documentation

EqualityOperator extends BinaryOperator
in package

Application

Represents the comparator '='

Properties

$lhs : mixed
$rhs : mixed
$precedence : mixed
$type : Type|null

Methods

__construct() : mixed: Construct a binary operator
abs() : Abs: Apply the ABS function to the number
accept() : mixed: Visit the current Node
add() : AddOperator: Apply the ADD operator to the number
and() : AndOperator: Construct a 'AND' boolean expression
as() : AliasOperator: Construct an alias for the current node
asc() : AscOperator: Construct an ascending order for the current node
average() : AverageFunction: Apply the AVERAGE function to the number
caseWhen() : WhenNode: Construct a CASE WHEN expression (without value)
cast() : Cast: Cast the current node to a given type
coalesce() : mixed
count() : CountFunction: Apply the COUNT function to the number
desc() : DescOperator: Construct a descending order for the current node
div() : DivOperator: Apply the DIV operator to the number
eq() : EqualityOperator|IsNullOperator: Construct a '=' boolean expression
false() : EqualityOperator|IsNullOperator: Construct a Node corresponding to a non tautology
firstValue() : mixed: Construct a FIRST_VALUE function from the current node
floor() : Floor: Apply the FLOOR function to the number
format() : Format: Format the number
getLeft() : Literal|Node: Getter for the left operand
getPrecedence() : int
getRight() : Literal|Node: Getter for the right operand
getType() : Type|null: Get the type of the Node
grouping() : Grouping: Construct a Grouping node
gt() : GreaterThanOperator: Apply the GREATER THAN operator to the number
gteq() : GreaterOrEqualOperator: Apply the GREATER OR EQUAL operator to the number
in() : InOperator|NotInOperator: Construct a 'IN' boolean expression
json() : mixed
lastValue() : mixed: Construct a LAST_VALUE function from the current node
log() : Log: Apply the LOG function to the number
log10() : Log: Apply the LOG function to the number with base 10
lt() : LesserThanOperator: Apply the LESS THAN operator to the number
lteq() : LesserOrEqualOperator: Apply the LESS OR EQUAL operator to the number
maximum() : MaximumFunction: Apply the MAXIMUM function to the number
minimum() : MinimumFunction: Apply the MINIMUM function to the number
mul() : MulOperator: Apply the MUL operator to the number
neq() : NotEqualityOperator|IsNotNullOperator: Construct a '!=' boolean expression
nodeArray() : array<string|int, mixed>: transform any object into a array of Node
not() : NotOperator: Construct a 'NOT' boolean expression
notIn() : NotInOperator|InOperator: Construct a 'NOT IN' boolean expression
of() : Literal|Node: Transform any object into a Node (does nothing on a Node)
or() : OrOperator: Construct a 'OR' boolean expression
pow() : Pow: Apply the POW function to the number
repeat() : Repeat: Repeat the current node $times times
setType() : void: Set the type of the Node
standardizeArray() : array<string|int, mixed>: Transform any object into a array
sub() : SubOperator: Apply the SUB operator to the number
sum() : SumFunction: Apply the SUM function to the number
table() : Table: Construct a Table node
toSql() : mixed: transform the node into a SQL query string
true() : EqualityOperator|IsNullOperator: Construct a Node corresponding to a tautology
tuple() : ExpressionList: Construct a Tuple node
typed() : Node: Set the type of the Node and return the Node
when() : WhenNode: Construct a CASE expression from the current node and define the first WHEN clause with a given condition

$lhs


    protected
        mixed
    $lhs

$rhs


    protected
        mixed
    $rhs

$precedence


    private
    static    mixed
    $precedence
     = [[\PhpParser\Node\Expr\Cast::class, \FND\QueryBuilder\Nodes\FunctionCall::class, \FND\QueryBuilder\Nodes\Literal::class], [\FND\QueryBuilder\Nodes\ExpressionList::class], [\FND\QueryBuilder\Nodes\Column::class], [\FND\QueryBuilder\Nodes\BinaryOperators\MulOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\DivOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\AddOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\SubOperator::class], [\FND\QueryBuilder\Nodes\UnaryOperators\IsNullOperator::class, \FND\QueryBuilder\Nodes\UnaryOperators\IsNotNullOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\InOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\NotInOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\MatchOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\LesserOrEqualOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\LesserThanOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\GreaterOrEqualOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\GreaterThanOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\EqualityOperator::class, \FND\QueryBuilder\Nodes\BinaryOperators\NotEqualityOperator::class], [\FND\QueryBuilder\Nodes\NotOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\AndOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\OrOperator::class], [\FND\QueryBuilder\Nodes\BinaryOperators\AliasOperator::class]]

$type


    private
        Type|null
    $type
     = null

__construct()

Construct a binary operator


    public
                    __construct(mixed $lhs, mixed $rhs) : mixed

Parameters

$lhs : mixed: the left operand
$rhs : mixed: the right operand

abs()

Apply the ABS function to the number


    public
                    abs() : Abs

Return values

Abs —

the ABS function

accept()

Visit the current Node


    public
                    accept(mixed $visitor) : mixed

Parameters

$visitor : mixed: a visitor

Return values

mixed —

the result string of the visit

add()

Apply the ADD operator to the number


    public
                    add(mixed $other) : AddOperator

Parameters

$other : mixed: mixed the other number

Return values

AddOperator —

the ADD operator

and()

Construct a 'AND' boolean expression


    public
                    and(mixed $other) : AndOperator

Parameters

$other : mixed: mixed the right operand

Return values

AndOperator —

the AND node

as()

Construct an alias for the current node


    public
                    as(mixed $alias) : AliasOperator

Parameters

$alias : mixed: the alias

Return values

AliasOperator —

the alias node

asc()

Construct an ascending order for the current node


    public
                    asc() : AscOperator

Return values

AscOperator —

the ascending order node

average()

Apply the AVERAGE function to the number


    public
                    average([mixed $groups = NULL ][, mixed $orders = NULL ]) : AverageFunction

Parameters

$groups : mixed = NULL: mixed the groups
$orders : mixed = NULL: mixed the orders

Return values

AverageFunction —

the AVERAGE function

caseWhen()

Construct a CASE WHEN expression (without value)


    public
            static        caseWhen(mixed $condition) : WhenNode

Parameters

$condition : mixed: the first WHEN clause condition

Return values

WhenNode —

the CASE WHEN expression

cast()

Cast the current node to a given type


    public
                    cast(Type $type) : Cast

Parameters

$type : Type: the type to cast to

Return values

Cast —

the cast node

coalesce()


    public
                    coalesce(mixed $args) : mixed

Parameters

$args : mixed

count()

Apply the COUNT function to the number


    public
                    count([mixed $groups = NULL ][, mixed $orders = NULL ]) : CountFunction

Parameters

$groups : mixed = NULL: mixed the groups
$orders : mixed = NULL: mixed the orders

Return values

CountFunction —

the COUNT function

desc()

Construct a descending order for the current node


    public
                    desc() : DescOperator

Return values

DescOperator —

the descending order node

div()

Apply the DIV operator to the number


    public
                    div(mixed $other) : DivOperator

Parameters

$other : mixed: mixed the other number

Return values

DivOperator —

the DIV operator

eq()

Construct a '=' boolean expression


    public
                    eq(mixed $other) : EqualityOperator|IsNullOperator

Parameters

$other : mixed: the other operand

Return values

EqualityOperator|IsNullOperator —

the equality node

false()

Construct a Node corresponding to a non tautology


    public
            static        false() : EqualityOperator|IsNullOperator

Return values

EqualityOperator|IsNullOperator

firstValue()

Construct a FIRST_VALUE function from the current node


    public
                    firstValue([mixed $groups = [] ][, mixed $orders = [] ][, mixed $rows = [] ][, mixed $nullsDirective = 0 ]) : mixed

Parameters

$groups : mixed = []: values to partitioned by (for window functions)
$orders : mixed = []: values to order with (for window functions)
$rows : mixed = []: values to bound with (for window functions)
$nullsDirective : mixed = 0

floor()

Apply the FLOOR function to the number


    public
                    floor() : Floor

Return values

Floor —

the FLOOR function

format()

Format the number


    public
                    format(mixed $format[, mixed $locale = NULL ]) : Format

Parameters

$format : mixed: string the format to apply
$locale : mixed = NULL: string the locale to use

Return values

Format —

the formatted number

getLeft()

Getter for the left operand


    public
                    getLeft() : Literal|Node

Return values

Literal|Node —

the left operand

getPrecedence()


    public
                    getPrecedence() : int

Return values

int

getRight()

Getter for the right operand


    public
                    getRight() : Literal|Node

Return values

Literal|Node —

the right operand

getType()

Get the type of the Node


    public
                    getType() : Type|null

Return values

Type|null —

the type

grouping()

Construct a Grouping node


    public
            static        grouping(mixed $node) : Grouping

Parameters

$node : mixed: a node

Return values

Grouping —

the new Grouping node

gt()

Apply the GREATER THAN operator to the number


    public
                    gt(mixed $other) : GreaterThanOperator

Parameters

$other : mixed

Return values

GreaterThanOperator —

the GREATER THAN operator

gteq()

Apply the GREATER OR EQUAL operator to the number


    public
                    gteq(mixed $other) : GreaterOrEqualOperator

Parameters

$other : mixed: mixed the other number

Return values

GreaterOrEqualOperator —

the GREATER OR EQUAL operator

in()

Construct a 'IN' boolean expression


    public
                    in([mixed $others = NULL ]) : InOperator|NotInOperator

Parameters

$others : mixed = NULL: the other operands

Return values

InOperator|NotInOperator

json()


    public
                    json() : mixed

lastValue()

Construct a LAST_VALUE function from the current node


    public
                    lastValue([mixed $groups = [] ][, mixed $orders = [] ][, mixed $rows = [] ][, mixed $nullsDirective = 0 ]) : mixed

Parameters

$groups : mixed = []: values to partitioned by (for window functions)
$orders : mixed = []: values to order with (for window functions)
$rows : mixed = []: values to bound with (for window functions)
$nullsDirective : mixed = 0

log()

Apply the LOG function to the number


    public
                    log([mixed $base = NULL ]) : Log

Parameters

$base : mixed = NULL: mixed the base of the logarithm

Return values

Log —

the LOG function

log10()

Apply the LOG function to the number with base 10


    public
                    log10() : Log

Return values

Log —

the LOG function

lt()

Apply the LESS THAN operator to the number


    public
                    lt(mixed $other) : LesserThanOperator

Parameters

$other : mixed: mixed the other number

Return values

LesserThanOperator —

the LESS THAN operator

lteq()

Apply the LESS OR EQUAL operator to the number


    public
                    lteq(mixed $other) : LesserOrEqualOperator

Parameters

$other : mixed: mixed the other number

Return values

LesserOrEqualOperator —

the LESS OR EQUAL operator

maximum()

Apply the MAXIMUM function to the number


    public
                    maximum([mixed $groups = NULL ][, mixed $orders = NULL ]) : MaximumFunction

Parameters

$groups : mixed = NULL: mixed the groups
$orders : mixed = NULL: mixed the orders

Return values

MaximumFunction —

the MAXIMUM function

minimum()

Apply the MINIMUM function to the number


    public
                    minimum([mixed $groups = NULL ][, mixed $orders = NULL ]) : MinimumFunction

Parameters

$groups : mixed = NULL: mixed the groups
$orders : mixed = NULL: mixed the orders

Return values

MinimumFunction —

the MINIMUM function

mul()

Apply the MUL operator to the number


    public
                    mul(mixed $other) : MulOperator

Parameters

$other : mixed: mixed the other number

Return values

MulOperator —

the MUL operator

neq()

Construct a '!=' boolean expression


    public
                    neq(mixed $other) : NotEqualityOperator|IsNotNullOperator

Parameters

$other : mixed: the other operand

Return values

NotEqualityOperator|IsNotNullOperator

nodeArray()

transform any object into a array of Node


    public
            static        nodeArray(mixed $args) : array<string|int, mixed>

Parameters

$args : mixed: any object

Return values

array<string|int, mixed> —

an array of Node

not()

Construct a 'NOT' boolean expression


    public
                    not() : NotOperator

Return values

NotOperator —

the NOT node

notIn()

Construct a 'NOT IN' boolean expression


    public
                    notIn([mixed $others = NULL ]) : NotInOperator|InOperator

Parameters

$others : mixed = NULL: the other operands

Return values

NotInOperator|InOperator

of()

Transform any object into a Node (does nothing on a Node)


    public
            static        of(mixed $value) : Literal|Node

Parameters

$value : mixed: any value

Return values

Literal|Node —

a Node

or()

Construct a 'OR' boolean expression


    public
                    or(mixed $other) : OrOperator

Parameters

$other : mixed: mixed the right operand

Return values

OrOperator —

the OR node

pow()

Apply the POW function to the number


    public
                    pow(mixed $exponent) : Pow

Parameters

$exponent : mixed: mixed the exponent

Return values

Pow —

the POW function

repeat()

Repeat the current node $times times


    public
                    repeat(mixed $times) : Repeat

Parameters

$times : mixed: the number of times to repeat the current node

Return values

Repeat —

the repeated node

setType()

Set the type of the Node


    public
                    setType(Type $type) : void

Parameters

$type : Type: the type

standardizeArray()

Transform any object into a array


    public
            static        standardizeArray(mixed $args) : array<string|int, mixed>

Parameters

$args : mixed: the object

Return values

array<string|int, mixed> —

the array

sub()

Apply the SUB operator to the number


    public
                    sub(mixed $other) : SubOperator

Parameters

$other : mixed: mixed the other number

Return values

SubOperator —

the SUB operator

sum()

Apply the SUM function to the number


    public
                    sum([mixed $groups = NULL ][, mixed $orders = NULL ]) : SumFunction

Parameters

$groups : mixed = NULL: mixed the groups
$orders : mixed = NULL: mixed the orders

Return values

SumFunction —

the SUM function

table()

Construct a Table node


    public
            static        table(mixed $name) : Table

Parameters

$name : mixed: the table name

Return values

Table —

the table

toSql()

transform the node into a SQL query string


    public
                    toSql([mixed $connection = NULL ]) : mixed

Parameters

$connection : mixed = NULL: the DB connection concerned (to select the right visitor)

Return values

mixed —

the SQL string

true()

Construct a Node corresponding to a tautology


    public
            static        true() : EqualityOperator|IsNullOperator

Return values

EqualityOperator|IsNullOperator

tuple()

Construct a Tuple node


    public
            static        tuple(mixed $array) : ExpressionList

Parameters

$array : mixed: a list

Return values

ExpressionList —

the new Tuple node

typed()

Set the type of the Node and return the Node


    public
                    typed(Type $type) : Node

Parameters

$type : Type: the type

Return values

Node —

the current Node

when()

Construct a CASE expression from the current node and define the first WHEN clause with a given condition


    public
                    when(mixed $condition) : WhenNode

Parameters

$condition : mixed

Return values

WhenNode —

the case node

EqualityOperator extends BinaryOperator in package Application

Table of Contents

Properties

Methods

Properties

$lhs

$rhs

$precedence

$type

Methods

__construct()

Parameters

abs()

Return values

accept()

Parameters

Return values

add()

Parameters

Return values

and()

Parameters

Return values

as()

Parameters

Return values

asc()

Return values

average()

Parameters

Return values

caseWhen()

Parameters

Return values

cast()

Parameters

Return values

coalesce()

Parameters

count()

Parameters

Return values

desc()

Return values

div()

Parameters

Return values

eq()

Parameters

Return values

false()

Return values

firstValue()

Parameters

floor()

Return values

format()

Parameters

Return values

getLeft()

Return values

getPrecedence()

Return values

getRight()

Return values

getType()

Return values

grouping()

Parameters

Return values

gt()

Parameters

Return values

gteq()

Parameters

Return values

in()

Parameters

Return values

json()

EqualityOperator extends BinaryOperator
in package

Application