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); } }