Documentation

IsNullOperator extends UnaryOperator
in package

Represents the IS NULL operator

Table of Contents

Properties

$arg  : mixed
$precedence  : mixed
$type  : Type|null

Methods

__construct()  : mixed
Construct an unary operator
accept()  : mixed
Visit the current Node
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
caseWhen()  : WhenNode
Construct a CASE WHEN expression (without value)
cast()  : Cast
Cast the current node to a given type
coalesce()  : mixed
desc()  : DescOperator
Construct a descending order for the current node
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
getArg()  : Literal|Node
Getter of the operand
getPrecedence()  : int
getType()  : Type|null
Get the type of the Node
grouping()  : Grouping
Construct a Grouping node
in()  : InOperator|NotInOperator
Construct a 'IN' boolean expression
json()  : mixed
lastValue()  : mixed
Construct a LAST_VALUE function from the current node
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
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
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

Properties

$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]]

Methods

__construct()

Construct an unary operator

public __construct(mixed $arg) : mixed
Parameters
$arg : mixed

the operand

accept()

Visit the current Node

public accept(mixed $visitor) : mixed
Parameters
$visitor : mixed

a visitor

Return values
mixed

the result string of the visit

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

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

getPrecedence()

public getPrecedence() : int
Return values
int

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

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

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

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

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

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

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


        
On this page

Search results