public function providerParseExpressionWithVariables() { $variables = array(1 => 'test', 2 => 'test2', 3 => 5, 4 => 10); $field = new FieldExpression('field'); $variable = new ScalarExpression('test'); $variable2 = new ScalarExpression('test2'); $maxFieldFunction = new FunctionExpression(FunctionExpression::FUNCTION_MAX); $maxFieldFunction->addArgument($variable2); $minFieldFunction = new FunctionExpression(FunctionExpression::FUNCTION_MIN, 'mf'); $minFieldFunction->addArgument($field); $minFieldFunction->addArgument($variable); $minFieldFunction2 = new FunctionExpression(FunctionExpression::FUNCTION_MIN, 'mf'); $minFieldFunction2->addArgument($field); $minFieldFunction2->addArgument($variable); $minFieldFunction2->addArgument($maxFieldFunction); $simpleMathematic = new MathematicalExpression(); $simpleMathematic->addExpression(new ScalarExpression(5)); $simpleMathematic->addExpression(new ScalarExpression(10), '+'); $mediumMathematic = new MathematicalExpression(); $mediumMathematic->addExpression(new ScalarExpression(5)); $mediumMathematic->addExpression($simpleMathematic, '/'); $minFunction = new FunctionExpression(FunctionExpression::FUNCTION_MIN); $minFunction->addArgument(new ScalarExpression(5)); $maxFunction = new FunctionExpression(FunctionExpression::FUNCTION_MAX); $maxFunction->addArgument($simpleMathematic); $functionMathematic = new MathematicalExpression(); $functionMathematic->addExpression($minFunction); $functionMathematic->addExpression($maxFunction); return array(array(new ScalarExpression('This is a test sentence'), '"This is a %1% sentence"', $variables), array(new ScalarExpression('test'), '%1%', $variables), array($maxFieldFunction, 'MAX(%2%)', $variables), array($minFieldFunction, 'MIN({field}, %1%) AS mf', $variables), array($minFieldFunction2, 'MIN({field}, %1%, MAX(%2%)) AS mf', $variables), array($simpleMathematic, '%3% + %4%', $variables), array($mediumMathematic, '%3% / (%3% + %4%)', $variables), array($functionMathematic, 'MIN(%3%) + MAX(%3% + %4%)', $variables)); }
private function parseMathematical($value) { $mathematicalOperators = $this->getMathematicalOperators(); $hasMathematicalOperator = false; foreach ($mathematicalOperators as $mathematicalOperator) { $mathematicalOperatorPosition = strpos($value, ' ' . $mathematicalOperator . ' '); if ($mathematicalOperatorPosition !== false) { $hasMathematicalOperator = true; break; } } if (!$hasMathematicalOperator) { return false; } if (strpos($value, ' AS ') !== false) { list($value, $alias) = explode(' AS ', $value); } else { $alias = null; } $tokens = $this->mathematicTokenizer->tokenize($value); if (count($tokens) == 1) { return false; } $mathematicalExpression = new MathematicalExpression($alias); $currentExpression = ''; $mathematicalOperator = null; foreach ($tokens as $token) { if (in_array($token, $mathematicalOperators)) { $mathematicalOperator = $token; continue; } $expression = $this->parseExpression($token); $mathematicalExpression->addExpression($expression, $mathematicalOperator); } return $mathematicalExpression; }
/** * Create the SQL of a mathematical expression * @param zibo\library\database\manipulation\expression\MathematicalExpression $expression * @param boolean $useAlias * @return string SQL of the mathematical expression */ protected function parseMathematicalExpression(MathematicalExpression $expression, $useAlias = true) { $parts = $expression->getParts(); $sql = ''; foreach ($parts as $part) { if ($sql) { $sql .= ' ' . $part->getOperator() . ' '; } $sql .= $this->parseExpression($part->getExpression(), false); } return '(' . $sql . ')'; }
/** * Copies a node * @param integer|Node $node Id of the node or the node to copy * @param boolean $recursive Set to true to also copy the children of the node * @param boolean $reorder Set to false to just copy the order index instead of adding the copied node after the source node * @param boolean $keepOriginalName Set to true to keep the name untouched, else a suffix like (copy) or (copy 2, 3 ...) will be added to the name of the copy * @param boolean $copyRoutes Set to true to copy the routes of the nodes. This will only work when copying a root node, else a validation error will occur * @param boolean $resetCopyTable Set to false for recursive copying * @param boolean $newParent Provide a new parent for the copy, needed for recursive copying * @return null */ public function copy($node, $recursive = true, $reorder = true, $keepOriginalName = false, $copyRoutes = false, $resetCopyTable = true, $newParent = null) { $id = $this->getPrimaryKey($node); $node = $this->getNode($id, 1); if ($resetCopyTable) { $this->copyTable = array(); } $copy = $this->createData(); $nameSuffix = ''; if (!$keepOriginalName) { $nameSuffix = $this->getNameSuffixForCopiedNode($node->parent, $node->name, $node->dataLocale); } $copy->name = $node->name . $nameSuffix; $copy->type = $node->type; if ($newParent) { $copy->parent = $newParent; } else { $copy->parent = $node->parent; } if ($reorder) { $copy->orderIndex = $node->orderIndex + 1; } else { $copy->orderIndex = $node->orderIndex; } if ($copyRoutes) { $copy->route = $node->route; } $isTransactionStarted = $this->startTransaction(); try { $this->copyNodeSettings($node, $copy); $this->save($copy); $localizedModel = $this->meta->getLocalizedModel(); $query = $localizedModel->createQuery(); $query->addCondition('{dataId} = %1%', $node->id); $localizedNodes = $query->query(); foreach ($localizedNodes as $localizedNode) { $nameSuffix = ''; if (!$keepOriginalName) { $nameSuffix = $this->getNameSuffixForCopiedNode($node->parent, $localizedNode->name, $localizedNode->dataLocale); } $copyLocalizedNode = $this->createData(false); $copyLocalizedNode->id = $copy->id; $copyLocalizedNode->name = $localizedNode->name . $nameSuffix; if ($copyRoutes) { $copyLocalizedNode->route = $localizedNode->route; } $copyLocalizedNode->dataLocale = $localizedNode->dataLocale; $this->save($copyLocalizedNode); } if ($reorder) { $orderFieldExpression = new FieldExpression('orderIndex'); $mathExpression = new MathematicalExpression(); $mathExpression->addExpression($orderFieldExpression); $mathExpression->addExpression(new ScalarExpression(1)); $idCondition = new SimpleCondition(new FieldExpression('id'), new ScalarExpression($copy->id), Condition::OPERATOR_NOT_EQUALS); $parentCondition = new SimpleCondition(new FieldExpression('parent'), new ScalarExpression($copy->parent), Condition::OPERATOR_EQUALS); $greaterCondition = new SimpleCondition($orderFieldExpression, new ScalarExpression($copy->orderIndex), Condition::OPERATOR_GREATER_OR_EQUALS); $condition = new NestedCondition(); $condition->addCondition($idCondition); $condition->addCondition($parentCondition); $condition->addCondition($greaterCondition); $updateStatement = new UpdateStatement(); $updateStatement->addTable(new TableExpression($this->getName())); $updateStatement->addValue($orderFieldExpression, $mathExpression); $updateStatement->addCondition($condition); $this->executeStatement($updateStatement); } if ($recursive) { $query = $this->createQuery(); $query->setFields('{id}, {parent}, {orderIndex}'); $query->addCondition('{parent} = \'' . $node->getPath() . '\''); // when copying a site, the path is numeric and won't be escaped by the orm $query->addOrderBy('{orderIndex} ASC'); $children = $query->query(); $path = $copy->getPath(); foreach ($children as $child) { $childCopy = $this->copy($child->id, true, false, true, $copyRoutes, false, $path); } } $this->copyTable[$id] = $copy->id; $this->commitTransaction($isTransactionStarted); } catch (Exception $exception) { $this->rollbackTransaction($isTransactionStarted); throw $exception; } return $copy; }