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

  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.      * @api
  57.      */
  58.     public function createQuery(
  59.         SourceInterface $source,
  60.         ConstraintInterface $constraint = null,
  61.         array $orderings = [],
  62.         array $columns = []
  63.     ) {
  64.         return $this->factory->get(
  65.             QueryObjectModel::class,
  66.             [$this->objectManager, $source, $constraint, $orderings, $columns]
  67.         );
  68.     }
  70.     // TODO: should we use the factory ->get here? but this would mean all of them need to expect the factory as first parameter
  71.     // or refactor the factory to make the first param optional.
  73.     /**
  74.      * {@inheritDoc}
  75.      *
  76.      * @api
  77.      */
  78.     public function selector($selectorName, $nodeTypeName)
  79.     {
  80.         return new Selector($selectorName, $nodeTypeName);
  81.     }
  83.     /**
  84.      * {@inheritDoc}
  85.      *
  86.      * @api
  87.      */
  88.     public function join(SourceInterface $left, SourceInterface $right, $joinType, JoinConditionInterface $joinCondition)
  89.     {
  90.         return new Join($left, $right, $joinType, $joinCondition);
  91.     }
  93.     /**
  94.      * {@inheritDoc}
  95.      *
  96.      * @api
  97.      */
  98.     public function equiJoinCondition($selector1Name, $property1Name, $selector2Name, $property2Name)
  99.     {
  100.         return new EquiJoinCondition($selector1Name, $property1Name, $selector2Name, $property2Name);
  101.     }
  103.     /**
  104.      * {@inheritDoc}
  105.      *
  106.      * @api
  107.      */
  108.     public function sameNodeJoinCondition($selector1Name, $selector2Name, $selector2Path = null)
  109.     {
  110.         return new SameNodeJoinCondition($selector1Name, $selector2Name, $selector2Path);
  111.     }
  113.     /**
  114.      * {@inheritDoc}
  115.      *
  116.      * @api
  117.      */
  118.     public function childNodeJoinCondition($childSelectorName, $parentSelectorName)
  119.     {
  120.         return new ChildNodeJoinCondition($childSelectorName, $parentSelectorName);
  121.     }
  123.     /**
  124.      * {@inheritDoc}
  125.      *
  126.      * @api
  127.      */
  128.     public function descendantNodeJoinCondition($descendantSelectorName, $ancestorSelectorName)
  129.     {
  130.         return new DescendantNodeJoinCondition($descendantSelectorName, $ancestorSelectorName);
  131.     }
  133.     /**
  134.      * {@inheritDoc}
  135.      *
  136.      * @api
  137.      */
  138.     public function andConstraint(ConstraintInterface $constraint1, ConstraintInterface $constraint2)
  139.     {
  140.         return new AndConstraint($constraint1, $constraint2);
  141.     }
  143.     /**
  144.      * {@inheritDoc}
  145.      *
  146.      * @api
  147.      */
  148.     public function orConstraint(ConstraintInterface $constraint1, ConstraintInterface $constraint2)
  149.     {
  150.         return new OrConstraint($constraint1, $constraint2);
  151.     }
  153.     /**
  154.      * {@inheritDoc}
  155.      *
  156.      * @api
  157.      */
  158.     public function notConstraint(ConstraintInterface $constraint)
  159.     {
  160.         return new NotConstraint($constraint);
  161.     }
  163.     /**
  164.      * {@inheritDoc}
  165.      *
  166.      * @api
  167.      */
  168.     public function comparison(DynamicOperandInterface $operand1, $operator, StaticOperandInterface $operand2)
  169.     {
  170.         return new ComparisonConstraint($operand1, $operator, $operand2);
  171.     }
  173.     /**
  174.      * {@inheritDoc}
  175.      *
  176.      * @api
  177.      */
  178.     public function propertyExistence($selectorName, $propertyName)
  179.     {
  180.         return new PropertyExistence($selectorName, $propertyName);
  181.     }
  183.     /**
  184.      * {@inheritDoc}
  185.      *
  186.      * @throws InvalidArgumentException
  187.      *
  188.      * @api
  189.      */
  190.     public function fullTextSearch($selectorName, $propertyName, $fullTextSearchExpression)
  191.     {
  192.         return new FullTextSearchConstraint($selectorName, $propertyName, $fullTextSearchExpression);
  193.     }
  195.     /**
  196.      * {@inheritDoc}
  197.      *
  198.      * @api
  199.      */
  200.     public function sameNode($selectorName, $path)
  201.     {
  202.         return new SameNode($selectorName, $path);
  203.     }
  205.     /**
  206.      * {@inheritDoc}
  207.      *
  208.      * @api
  209.      */
  210.     public function childNode($selectorName, $path)
  211.     {
  212.         return new ChildNodeConstraint($selectorName, $path);
  213.     }
  215.     /**
  216.      * {@inheritDoc}
  217.      *
  218.      * @api
  219.      */
  220.     public function descendantNode($selectorName, $path)
  221.     {
  222.         return new DescendantNodeConstraint($selectorName, $path);
  223.     }
  225.     /**
  226.      * {@inheritDoc}
  227.      *
  228.      * @throws InvalidArgumentException
  229.      *
  230.      * @api
  231.      */
  232.     public function propertyValue($selectorName, $propertyName)
  233.     {
  234.         return new PropertyValue($selectorName, $propertyName);
  235.     }
  237.     /**
  238.      * {@inheritDoc}
  239.      *
  240.      * @api
  241.      */
  242.     public function length(PropertyValueInterface $propertyValue)
  243.     {
  244.         return new Length($propertyValue);
  245.     }
  247.     /**
  248.      * {@inheritDoc}
  249.      *
  250.      * @throws InvalidArgumentException
  251.      *
  252.      * @api
  253.      */
  254.     public function nodeName($selectorName)
  255.     {
  256.         return new NodeName($selectorName);
  257.     }
  259.     /**
  260.      * {@inheritDoc}
  261.      *
  262.      * @api
  263.      */
  264.     public function nodeLocalName($selectorName)
  265.     {
  266.         return new NodeLocalName($selectorName);
  267.     }
  269.     /**
  270.      * {@inheritDoc}
  271.      *
  272.      * @throws InvalidArgumentException
  273.      *
  274.      * @api
  275.      */
  276.     public function fullTextSearchScore($selectorName)
  277.     {
  278.         return new FullTextSearchScore($selectorName);
  279.     }
  281.     /**
  282.      * {@inheritDoc}
  283.      *
  284.      * @api
  285.      */
  286.     public function lowerCase(DynamicOperandInterface $operand)
  287.     {
  288.         return new LowerCase($operand);
  289.     }
  291.     /**
  292.      * {@inheritDoc}
  293.      *
  294.      * @api
  295.      */
  296.     public function upperCase(DynamicOperandInterface $operand)
  297.     {
  298.         return new UpperCase($operand);
  299.     }
  301.     /**
  302.      * {@inheritDoc}
  303.      *
  304.      * @api
  305.      */
  306.     public function bindVariable($bindVariableName)
  307.     {
  308.         return new BindVariableValue($bindVariableName);
  309.     }
  311.     /**
  312.      * {@inheritDoc}
  313.      *
  314.      * @api
  315.      */
  316.     public function literal($literalValue)
  317.     {
  318.         return new Literal($literalValue);
  319.     }
  321.     /**
  322.      * {@inheritDoc}
  323.      *
  324.      * @api
  325.      */
  326.     public function ascending(DynamicOperandInterface $operand)
  327.     {
  328.         return new Ordering($operand, QueryObjectModelConstantsInterface::JCR_ORDER_ASCENDING);
  329.     }
  331.     /**
  332.      * {@inheritDoc}
  333.      *
  334.      * @api
  335.      */
  336.     public function descending(DynamicOperandInterface $operand)
  337.     {
  338.         return new Ordering($operand, QueryObjectModelConstantsInterface::JCR_ORDER_DESCENDING);
  339.     }
  341.     /**
  342.      * {@inheritDoc}
  343.      *
  344.      * @throws \InvalidArgumentException
  345.      *
  346.      * @api
  347.      */
  348.     public function column($selectorName, $propertyName = null, $columnName = null)
  349.     {
  350.         return new Column($selectorName, $propertyName, $columnName);
  351.     }
  352. }