vendor/jackalope/jackalope/src/Jackalope/Query/QOM/QueryObjectModelFactory.php line 178

Open in your IDE?
  1. <?php
  3. namespace Jackalope\Query\QOM;
  5. use InvalidArgumentException;
  6. use Jackalope\ObjectManager;
  7. use Jackalope\FactoryInterface;
  8. use PHPCR\Query\QOM\QueryObjectModelConstantsInterface;
  9. use PHPCR\Query\QOM\QueryObjectModelFactoryInterface;
  10. use PHPCR\Query\QOM\SourceInterface;
  11. use PHPCR\Query\QOM\ConstraintInterface;
  12. use PHPCR\Query\QOM\JoinConditionInterface;
  13. use PHPCR\Query\QOM\DynamicOperandInterface;
  14. use PHPCR\Query\QOM\StaticOperandInterface;
  15. use PHPCR\Query\QOM\PropertyValueInterface;
  17. /**
  18.  * {@inheritDoc}
  19.  *
  20.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  21.  * @license http://opensource.org/licenses/MIT MIT License
  22.  *
  23.  * @api
  24.  */
  25. class QueryObjectModelFactory implements QueryObjectModelFactoryInterface
  26. {
  27.     /**
  28.      * The factory to instantiate objects
  29.      *
  30.      * @var FactoryInterface
  31.      */
  32.     protected $factory;
  34.     /**
  35.      * @var ObjectManager
  36.      */
  37.     protected $objectManager;
  39.     /**
  40.      * Create the query object model factory - get this from the QueryManager
  41.      *
  42.      * @param FactoryInterface $factory       the object factory
  43.      * @param ObjectManager    $objectManager only used to create the query (can
  44.      *      be omitted if you do not want to execute the query but just use it
  45.      *      with a parser)
  46.      */
  47.     public function __construct(FactoryInterface $factory, ObjectManager $objectManager = null)
  48.     {
  49.         $this->factory = $factory;
  50.         $this->objectManager = $objectManager;
  51.     }
  53.     /**
  54.      * {@inheritDoc}
  55.      *
  56.      * @return \PHPCR\Query\QOM\QueryObjectModelInterface the query
  57.      *
  58.      * @api
  59.      */
  60.     public function createQuery(
  61.         SourceInterface $source,
  62.         ConstraintInterface $constraint = null,
  63.         array $orderings = [],
  64.         array $columns = []
  65.     ) {
  66.         return $this->factory->get(
  67.             QueryObjectModel::class,
  68.             [$this->objectManager, $source, $constraint, $orderings, $columns]
  69.         );
  70.     }
  72.     // TODO: should we use the factory ->get here? but this would mean all of them need to expect the factory as first parameter
  73.     // or refactor the factory to make the first param optional.
  75.     /**
  76.      * {@inheritDoc}
  77.      *
  78.      * @return \PHPCR\Query\QOM\SelectorInterface the selector
  79.      *
  80.      * @api
  81.      */
  82.     public function selector($selectorName, $nodeTypeName)
  83.     {
  84.         return new Selector($selectorName, $nodeTypeName);
  85.     }
  87.     /**
  88.      * {@inheritDoc}
  89.      *
  90.      * @return \PHPCR\Query\QOM\JoinInterface the join
  91.      *
  92.      * @api
  93.      */
  94.     public function join(SourceInterface $left, SourceInterface $right, $joinType, JoinConditionInterface $joinCondition)
  95.     {
  96.         return new Join($left, $right, $joinType, $joinCondition);
  97.     }
  99.     /**
  100.      * {@inheritDoc}
  101.      *
  102.      * @return \PHPCR\Query\QOM\EquiJoinConditionInterface the constraint
  103.      *
  104.      * @api
  105.      */
  106.     public function equiJoinCondition($selector1Name, $property1Name, $selector2Name, $property2Name)
  107.     {
  108.         return new EquiJoinCondition($selector1Name, $property1Name, $selector2Name, $property2Name);
  109.     }
  111.     /**
  112.      * {@inheritDoc}
  113.      *
  114.      * @return \PHPCR\Query\QOM\SameNodeJoinConditionInterface the constraint
  115.      *
  116.      * @api
  117.      */
  118.     public function sameNodeJoinCondition($selector1Name, $selector2Name, $selector2Path = null)
  119.     {
  120.         return new SameNodeJoinCondition($selector1Name, $selector2Name, $selector2Path);
  121.     }
  123.     /**
  124.      * {@inheritDoc}
  125.      *
  126.      * @return \PHPCR\Query\QOM\ChildNodeJoinConditionInterface the constraint
  127.      *
  128.      * @api
  129.      */
  130.     public function childNodeJoinCondition($childSelectorName, $parentSelectorName)
  131.     {
  132.         return new ChildNodeJoinCondition($childSelectorName, $parentSelectorName);
  133.     }
  135.     /**
  136.      * {@inheritDoc}
  137.      *
  138.      * @return \PHPCR\Query\QOM\DescendantNodeJoinConditionInterface the constraint
  139.      *
  140.      * @api
  141.      */
  142.     public function descendantNodeJoinCondition($descendantSelectorName, $ancestorSelectorName)
  143.     {
  144.         return new DescendantNodeJoinCondition($descendantSelectorName, $ancestorSelectorName);
  145.     }
  147.     /**
  148.      * {@inheritDoc}
  149.      *
  150.      * @return \PHPCR\Query\QOM\AndInterface the And constraint
  151.      *
  152.      * @api
  153.      */
  154.     public function andConstraint(ConstraintInterface $constraint1, ConstraintInterface $constraint2)
  155.     {
  156.         return new AndConstraint($constraint1, $constraint2);
  157.     }
  159.     /**
  160.      * {@inheritDoc}
  161.      *
  162.      * @return \PHPCR\Query\QOM\OrInterface the Or constraint
  163.      *
  164.      * @api
  165.      */
  166.     public function orConstraint(ConstraintInterface $constraint1, ConstraintInterface $constraint2)
  167.     {
  168.         return new OrConstraint($constraint1, $constraint2);
  169.     }
  171.     /**
  172.      * {@inheritDoc}
  173.      *
  174.      * @return \PHPCR\Query\QOM\NotInterface the Not constraint
  175.      *
  176.      * @api
  177.      */
  178.     public function notConstraint(ConstraintInterface $constraint)
  179.     {
  180.         return new NotConstraint($constraint);
  181.     }
  183.     /**
  184.      * {@inheritDoc}
  185.      *
  186.      * @return \PHPCR\Query\QOM\ComparisonInterface the constraint
  187.      *
  188.      * @api
  189.      */
  190.     public function comparison(DynamicOperandInterface $operand1, $operator, StaticOperandInterface $operand2)
  191.     {
  192.         return new ComparisonConstraint($operand1, $operator, $operand2);
  193.     }
  195.     /**
  196.      * {@inheritDoc}
  197.      *
  198.      * @return \PHPCR\Query\QOM\PropertyExistenceInterface the constraint
  199.      *
  200.      * @api
  201.      */
  202.     public function propertyExistence($selectorName, $propertyName)
  203.     {
  204.         return new PropertyExistence($selectorName, $propertyName);
  205.     }
  207.     /**
  208.      * {@inheritDoc}
  209.      *
  210.      * @return \PHPCR\Query\QOM\FullTextSearchInterface the constraint
  211.      *
  212.      * @throws InvalidArgumentException
  213.      *
  214.      * @api
  215.      */
  216.     public function fullTextSearch($selectorName, $propertyName, $fullTextSearchExpression)
  217.     {
  218.         return new FullTextSearchConstraint($selectorName, $propertyName, $fullTextSearchExpression);
  219.     }
  221.     /**
  222.      * {@inheritDoc}
  223.      *
  224.      * @return \PHPCR\Query\QOM\SameNodeInterface the constraint
  225.      *
  226.      * @api
  227.      */
  228.     public function sameNode($selectorName, $path)
  229.     {
  230.         return new SameNode($selectorName, $path);
  231.     }
  233.     /**
  234.      * {@inheritDoc}
  235.      *
  236.      * @return \PHPCR\Query\QOM\ChildNodeInterface the constraint
  237.      *
  238.      * @api
  239.      */
  240.     public function childNode($selectorName, $path)
  241.     {
  242.         return new ChildNodeConstraint($selectorName, $path);
  243.     }
  245.     /**
  246.      * {@inheritDoc}
  247.      *
  248.      * @return \PHPCR\Query\QOM\DescendantNodeInterface the constraint
  249.      *
  250.      * @api
  251.      */
  252.     public function descendantNode($selectorName, $path)
  253.     {
  254.         return new DescendantNodeConstraint($selectorName, $path);
  255.     }
  257.     /**
  258.      * {@inheritDoc}
  259.      *
  260.      * @return \PHPCR\Query\QOM\PropertyValueInterface the operand
  261.      *
  262.      * @throws InvalidArgumentException
  263.      *
  264.      * @api
  265.      */
  266.     public function propertyValue($selectorName, $propertyName)
  267.     {
  268.         return new PropertyValue($selectorName, $propertyName);
  269.     }
  271.     /**
  272.      * {@inheritDoc}
  273.      *
  274.      * @return \PHPCR\Query\QOM\LengthInterface the operand
  275.      *
  276.      * @api
  277.      */
  278.     public function length(PropertyValueInterface $propertyValue)
  279.     {
  280.         return new Length($propertyValue);
  281.     }
  283.     /**
  284.      * {@inheritDoc}
  285.      *
  286.      * @return \PHPCR\Query\QOM\NodeNameInterface the operand
  287.      *
  288.      * @throws InvalidArgumentException
  289.      *
  290.      * @api
  291.      */
  292.     public function nodeName($selectorName)
  293.     {
  294.         return new NodeName($selectorName);
  295.     }
  297.     /**
  298.      * {@inheritDoc}
  299.      *
  300.      * @return \PHPCR\Query\QOM\NodeLocalNameInterface the operand
  301.      *
  302.      * @api
  303.      */
  304.     public function nodeLocalName($selectorName)
  305.     {
  306.         return new NodeLocalName($selectorName);
  307.     }
  309.     /**
  310.      * {@inheritDoc}
  311.      *
  312.      * @return \PHPCR\Query\QOM\FullTextSearchScoreInterface the operand
  313.      *
  314.      * @throws InvalidArgumentException
  315.      *
  316.      * @api
  317.      */
  318.     public function fullTextSearchScore($selectorName)
  319.     {
  320.         return new FullTextSearchScore($selectorName);
  321.     }
  323.     /**
  324.      * {@inheritDoc}
  325.      *
  326.      * @return \PHPCR\Query\QOM\LowerCaseInterface the operand
  327.      *
  328.      * @api
  329.      */
  330.     public function lowerCase(DynamicOperandInterface $operand)
  331.     {
  332.         return new LowerCase($operand);
  333.     }
  335.     /**
  336.      * {@inheritDoc}
  337.      *
  338.      * @return \PHPCR\Query\QOM\UpperCaseInterface the operand
  339.      *
  340.      * @api
  341.      */
  342.     public function upperCase(DynamicOperandInterface $operand)
  343.     {
  344.         return new UpperCase($operand);
  345.     }
  347.     /**
  348.      * {@inheritDoc}
  349.      *
  350.      * @return \PHPCR\Query\QOM\BindVariableValueInterface the operand
  351.      *
  352.      * @api
  353.      */
  354.     public function bindVariable($bindVariableName)
  355.     {
  356.         return new BindVariableValue($bindVariableName);
  357.     }
  359.     /**
  360.      * {@inheritDoc}
  361.      *
  362.      * @return mixed the operand
  363.      *
  364.      * @api
  365.      */
  366.     public function literal($literalValue)
  367.     {
  368.         return new Literal($literalValue);
  369.     }
  371.     /**
  372.      * {@inheritDoc}
  373.      *
  374.      * @return \PHPCR\Query\QOM\OrderingInterface the ordering
  375.      *
  376.      * @api
  377.      */
  378.     public function ascending(DynamicOperandInterface $operand)
  379.     {
  380.         return new Ordering($operand, QueryObjectModelConstantsInterface::JCR_ORDER_ASCENDING);
  381.     }
  383.     /**
  384.      * {@inheritDoc}
  385.      *
  386.      * @return \PHPCR\Query\QOM\OrderingInterface the ordering
  387.      *
  388.      * @api
  389.      */
  390.     public function descending(DynamicOperandInterface $operand)
  391.     {
  392.         return new Ordering($operand, QueryObjectModelConstantsInterface::JCR_ORDER_DESCENDING);
  393.     }
  395.     /**
  396.      * {@inheritDoc}
  397.      *
  398.      * @return \PHPCR\Query\QOM\ColumnInterface the column
  399.      *
  400.      * @throws \InvalidArgumentException
  401.      *
  402.      * @api
  403.      */
  404.     public function column($selectorName, $propertyName = null, $columnName = null)
  405.     {
  406.         return new Column($selectorName, $propertyName, $columnName);
  407.     }
  408. }