public function DateInterval___construct(array $ArgumentExpressions)
{
if (!$ArgumentExpressions[0] instanceof EE\ConstantExpression) {
throw new PlatformException('Call to DateInterval::__construct() must contain a single constant value');
}
return Expression::Constant(new \DateInterval($ArgumentExpressions[0]->GetValue()));
}
public function __construct(ColumnData $ColumnData)
{
$ConstraintExpressions = [];
foreach ($ColumnData as $ColumnIdentifier => $Value) {
$Column = $ColumnData->GetColumn($ColumnIdentifier);
$ConstraintExpressions[] = Expression::BinaryOperation(Expression::Column($Column), Binary::Equality, Expression::PersistData($Column, Expression::Constant($Value)));
}
parent::__construct($ConstraintExpressions, Binary::LogicalAnd);
}
public function MapCastExpression($CastType, CoreExpression $CastValueExpression)
{
switch ($CastType) {
case O\Cast::Boolean:
return Expression::Conditional($CastValueExpression, Expression::Constant(1), Expression::Constant(0));
default:
return Expression::Cast($CastType, $CastValueExpression);
}
}
public function __construct(ForeignKey $ForeignKey)
{
$ReferencedColumnMap = $ForeignKey->GetReferencedColumnMap();
$ConstraintExpressions = [];
foreach ($ReferencedColumnMap as $PrimaryColumn) {
$ForeignColumn = $ReferencedColumnMap[$PrimaryColumn];
$ConstraintExpressions[] = Expression::BinaryOperation(Expression::Column($PrimaryColumn), Binary::Equality, Expression::Column($ForeignColumn));
}
parent::__construct($ConstraintExpressions, Binary::LogicalAnd);
}
protected function SelectQuery(QueryBuilder $QueryBuilder, Relational\Request $Request)
{
$QueryBuilder->Append('SELECT ');
foreach ($QueryBuilder->Delimit($Request->GetColumns(), ',') as $Column) {
$QueryBuilder->AppendExpression(Expression::ReviveColumn($Column));
$QueryBuilder->AppendIdentifier(' AS #', [$Column->GetIdentifier()]);
}
$QueryBuilder->AppendIdentifiers(' FROM # ', array_keys($Request->GetTables()), ', ');
$this->AppendCriterion($QueryBuilder, $Request->GetCriterion());
}
public function MapCastExpression($CastType, CoreExpression $CastValueExpression)
{
switch ($CastType) {
case O\Cast::Boolean:
return Expression::Conditional($CastValueExpression, Expression::Constant(1), Expression::Constant(0));
case O\Cast::Double:
return Expression::BinaryOperation($CastValueExpression, O\Binary::Addition, Expression::Literal('0.0'));
default:
return Expression::Cast($CastType, $CastValueExpression);
}
}
public function __construct(array $Expressions, $LogicalOperator = Binary::LogicalAnd)
{
$PredicateExpression = null;
foreach ($Expressions as $Expression) {
if ($PredicateExpression === null) {
$PredicateExpression = $Expression;
} else {
$PredicateExpression = Expression::BinaryOperation($PredicateExpression, $LogicalOperator, $Expression);
}
}
parent::__construct($PredicateExpression->GetLeftOperandExpression(), $PredicateExpression->GetOperator(), $PredicateExpression->GetRightOperandExpression());
}
public final function MapObjectExpression($Type, $Value)
{
if (isset($this->ObjectDataTypes[$Type])) {
$ObjectDataType = $this->ObjectDataTypes[$Type];
return Expression::Constant($ObjectDataType->ToPersistedValue($Value));
}
$MethodName = str_replace('\\', '_', $Type);
if (!method_exists($this, $MethodName)) {
throw new \Storm\Core\NotSupportedException('%s does not support mapping object instance of type %s', get_class($this), $Type);
}
return $this->{$MethodName}($Value);
}
protected final function MapExpression(Mapping\IEntityRelationalMap $EntityRelationalMap, O\Expression $Expression)
{
/* @var $ExpressionMapper RR\IExpressionMapper */
$ExpressionMapper = $this->GetDatabase()->GetPlatform()->GetExpressionMapper();
switch (true) {
case $Expression instanceof O\PropertyExpression:
return array_map([Expression::GetType(), 'ReviveColumn'], $EntityRelationalMap->GetMappedReviveColumns($Expression->GetProperty()));
case $Expression instanceof O\ConstantExpression:
return [$ExpressionMapper->MapConstantExpression($Expression->GetValue())];
case $Expression instanceof O\ObjectExpression:
if (!$Expression->HasInstance()) {
throw new Mapping\MappingException('Cannot map object expression without a valid object instance.');
}
return [$ExpressionMapper->MapObjectExpression($Expression->GetClassType(), $Expression->GetInstance())];
case $Expression instanceof O\PropertyFetchExpression:
$ObjectExpression = $Expression->GetObjectExpression();
return [$ExpressionMapper->MapPropertyFetchExpression($Expression->IsStatic() ? null : $this->MapExpression($EntityRelationalMap, $ObjectExpression)[0], $Expression->GetClassType(), $Expression->GetName())];
case $Expression instanceof O\MethodCallExpression:
$ObjectExpression = $Expression->GetObjectExpression();
return [$ExpressionMapper->MapMethodCallExpression($Expression->IsStatic() ? null : $this->MapExpression($EntityRelationalMap, $ObjectExpression)[0], $Expression->GetClassType(), $Expression->GetName(), array_map(function ($Expression) use(&$EntityRelationalMap) {
return $this->MapExpression($EntityRelationalMap, $Expression)[0];
}, $Expression->GetArgumentValueExpressions()))];
case $Expression instanceof O\ArrayExpression:
return [Expression::ValueList(array_map(function ($Expression) use(&$EntityRelationalMap) {
return $this->MapExpression($EntityRelationalMap, $Expression)[0];
}, $Expression->GetValueExpressions()))];
//Limitation: only one to one mapping for some expressions
//Limitation: only one to one mapping for some expressions
case $Expression instanceof O\AssignmentExpression:
$ColumnExpressions = array_map([Expression::GetType(), 'Column'], $EntityRelationalMap->GetMappedPersistColumns($Expression->GetProperty()));
$Operator = $this->OperatorMapper->MapAssignmentOperator($Expression->GetOperator());
$SetValueExpression = $this->MapExpression($EntityRelationalMap, $Expression->GetRightOperandExpression())[0];
return array_map(function ($ColumnExpression) use(&$ExpressionMapper, &$Operator, &$SetValueExpression) {
return $ExpressionMapper->MapAssignmentExpression($ColumnExpression, $Operator, $SetValueExpression);
}, $ColumnExpressions);
case $Expression instanceof O\BinaryOperationExpression:
return [$ExpressionMapper->MapBinaryOperationExpression($this->MapExpression($EntityRelationalMap, $Expression->GetLeftOperandExpression())[0], $this->OperatorMapper->MapBinaryOperator($Expression->GetOperator()), $this->MapExpression($EntityRelationalMap, $Expression->GetRightOperandExpression())[0])];
case $Expression instanceof O\UnaryOperationExpression:
return [$ExpressionMapper->MapUnaryOperationExpression($this->OperatorMapper->MapUnaryOperator($Expression->GetOperator()), $this->MapExpression($EntityRelationalMap, $Expression->GetOperandExpression())[0])];
case $Expression instanceof O\CastExpression:
return [$ExpressionMapper->MapCastExpression($this->OperatorMapper->MapCastOperator($Expression->GetCastType()), $this->MapExpression($EntityRelationalMap, $Expression->GetCastValueExpression())[0])];
case $Expression instanceof O\FunctionCallExpression:
return [$ExpressionMapper->MapFunctionCallExpression($Expression->GetName(), array_map(function ($Expression) use(&$EntityRelationalMap) {
return $this->MapExpression($EntityRelationalMap, $Expression)[0];
}, $Expression->GetArgumentValueExpressions()))];
case $Expression instanceof O\TernaryExpression:
return [$ExpressionMapper->MapIfExpression($this->MapExpression($EntityRelationalMap, $Expression->GetConditionExpression())[0], $this->MapExpression($EntityRelationalMap, $Expression->GetIfTrueExpression())[0], $this->MapExpression($EntityRelationalMap, $Expression->GetIfFalseExpression())[0])];
default:
throw new Mapping\MappingException('Unsupported object expression type %s given', get_class($Expression));
}
}
public function AddParentPredicateToRequest(Relational\Request $Request, array $ParentRows)
{
$ParentTable = $this->GetParentTable();
if ($ParentTable) {
$Request->AddTable($ParentTable);
}
$Request->AddColumns($this->GetReferencedColumns());
$MatchExpressions = [];
foreach ($ParentRows as $ParentRow) {
$ReferencedKey = $this->MapParentRowToRelatedKey($this->ForeignKey, $ParentRow);
$MatchExpressions[] = new Expressions\MatchesColumnDataExpression($ReferencedKey);
}
$Request->GetCriterion()->AddPredicateExpression(Expressions\Expression::CompoundBoolean($MatchExpressions, Expressions\Operators\Binary::LogicalOr));
}
public function GetPersistExpression(CoreExpression $Expression)
{
return Expression::FunctionCall('UNHEX', Expression::ValueList([$Expression]));
}
private function Subtract(CoreExpression $Expression, $Value)
{
return Expression::BinaryOperation($Expression, O\Binary::Subtraction, Expression::Constant($Value));
}
public function __construct(Column $Column)
{
parent::__construct($Column);
$this->ReviveExpression = $Column instanceof Column ? $Column->GetDataType()->GetReviveExpression(Expression::Column($Column)) : Expression::Column($Column);
}
private function TrimDefaultCharacters(array &$ArgumentExpressions)
{
if (!isset($ArgumentExpressions[1])) {
$ArgumentExpressions[1] = Expression::Constant(" \t\n\r\v");
}
}
private function OptimizeReviveColumnCompareConstantExpression(ReviveColumnExpression &$ColumnExpression, CoreExpression &$ConstantExpression)
{
$Column = $ColumnExpression->GetColumn();
$ColumnExpression = Expression::Column($Column);
$ConstantExpression = Expression::PersistData($Column, $ConstantExpression);
}
public function MapIfExpression(CoreExpression $ConditionExpression, CoreExpression $IfTrueExpression, CoreExpression $IfFalseExpression)
{
return Expression::Conditional($ConditionExpression, $IfTrueExpression, $IfFalseExpression);
}
public function sub(CoreExpression $ObjectExpression, array $ArgumentExpressions)
{
$IntervalExpression = $ArgumentExpressions[0];
if ($IntervalExpression instanceof E\ConstantExpression && $IntervalExpression->GetValue() instanceof \DateInterval) {
$IntervalValue = $ArgumentExpressions[0]->GetValue();
$IntervalValue->invert = $IntervalValue->invert === 1 ? 0 : 1;
$ArgumentExpressions[0] = $IntervalValue;
} else {
$ArgumentExpressions[0] = Expression::UnaryOperation(Operators\Unary::Negation, $IntervalExpression);
}
return $this->add($ObjectExpression, $ArgumentExpressions);
}
public function GetPersistExpression(CoreExpression $Expression)
{
return Expression::FunctionCall($this->PersistFunctionName, Expression::ValueList([$Expression]));
}
public function AppendDataAsInlineRow(QueryBuilder $QueryBuilder, array $Columns, Relational\ColumnData $ColumnData)
{
$QueryBuilder->Append(' SELECT ');
foreach ($QueryBuilder->Delimit($Columns, ', ') as $Column) {
$QueryBuilder->AppendExpression(Expression::PersistData($Column, Expression::Constant($ColumnData[$Column])));
}
}
public final function AppendColumnData(Relational\Columns\Column $Column, $Value)
{
$ValueExpression = Relational\Expressions\Expression::Constant($Value);
$PersistExpression = $Column->GetDataType()->GetPersistExpression($ValueExpression);
if ($ValueExpression === $PersistExpression) {
$this->AppendSingleValue($Value);
} else {
$this->ExpressionCompiler->Append($this, $PersistExpression);
}
}
