vendor/jackalope/jackalope/src/Jackalope/Query/Query.php line 108

Open in your IDE?
  1. <?php
  3. namespace Jackalope\Query;
  5. use PHPCR\UnsupportedRepositoryOperationException;
  6. use PHPCR\RepositoryException;
  7. use PHPCR\ItemNotFoundException;
  8. use PHPCR\Query\QueryInterface;
  9. use Jackalope\ObjectManager;
  10. use Jackalope\FactoryInterface;
  12. /**
  13.  * Abstract Query implementation for the different Query-languages
  14.  *
  15.  * This can never be legally created if the transport does not implement
  16.  * QueryInterface.
  17.  *
  18.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  19.  * @license http://opensource.org/licenses/MIT MIT License
  20.  *
  21.  * @api
  22.  */
  23. abstract class Query implements QueryInterface
  24. {
  25.     /**
  26.      * The factory to instantiate objects
  27.      *
  28.      * @var FactoryInterface
  29.      */
  30.     protected $factory;
  32.     /**
  33.      * The query statement
  34.      *
  35.      * @var string
  36.      */
  37.     protected $statement;
  39.     /**
  40.      * Limit for the query
  41.      *
  42.      * @var integer
  43.      */
  44.     protected $limit;
  46.     /**
  47.      * Offset to start results from
  48.      *
  49.      * @var integer
  50.      */
  51.     protected $offset;
  53.     /**
  54.      * The object manager to execute the query with.
  55.      *
  56.      * @var ObjectManager
  57.      */
  58.     protected $objectManager;
  60.     /**
  61.      * If this is a stored query, the path to the node that stores this query.
  62.      *
  63.      * @var string
  64.      */
  65.     protected $path;
  67.     /**
  68.      * Create a new query instance
  69.      *
  70.      * @param FactoryInterface $factory       the object factory
  71.      * @param string           $statement     The statement for this query
  72.      * @param ObjectManager    $objectManager (can be omitted if you do not want
  73.      *      to execute the query but just use it with a parser)
  74.      * @param string $path If this query is loaded from workspace with
  75.      *      QueryManager::getQuery(), path has to be provided here
  76.      */
  77.     public function __construct(FactoryInterface $factory, $statement, ObjectManager $objectManager = null, $path = null)
  78.     {
  79.         $this->factory = $factory;
  80.         $this->statement = $statement;
  81.         $this->objectManager = $objectManager;
  82.         $this->path = $path;
  83.     }
  85.     /**
  86.      * {@inheritDoc}
  87.      *
  88.      * @api
  89.      */
  90.     public function bindValue($varName, $value)
  91.     {
  92.         throw new RepositoryException('Not Implemented...');
  93.     }
  95.     /**
  96.      * {@inheritDoc}
  97.      *
  98.      * @api
  99.      */
  100.     public function execute()
  101.     {
  102.         if (null === $this->objectManager) {
  103.             // if the ObjectManager was not injected in the header. this is only supposed to happen in the DBAL client.
  104.             throw new RepositoryException('Jackalope implementation error: This query was built for parsing only. (There is no ObjectManager to run the query against.)');
  105.         }
  106.         $transport = $this->objectManager->getTransport();
  107.         $rawData = $transport->query($this);
  108.         $queryResult = $this->factory->get(QueryResult::class, [$rawData, $this->objectManager]);
  110.         return $queryResult;
  111.     }
  113.     /**
  114.      * {@inheritDoc}
  115.      *
  116.      * @api
  117.      */
  118.     public function cancel()
  119.     {
  120.         return false;
  121.     }
  123.     /**
  124.      * {@inheritDoc}
  125.      *
  126.      * @api
  127.      */
  128.     public function getBindVariableNames()
  129.     {
  130.         throw new RepositoryException('Not Implemented...');
  131.     }
  133.     /**
  134.      * {@inheritDoc}
  135.      *
  136.      * @api
  137.      */
  138.     public function setLimit($limit)
  139.     {
  140.         $this->limit = $limit;
  141.     }
  143.     /**
  144.      * Access the limit from the transport layer
  145.      *
  146.      * @return int the limit set with setLimit
  147.      */
  148.     public function getLimit()
  149.     {
  150.         return $this->limit;
  151.     }
  153.     /**
  154.      * {@inheritDoc}
  155.      *
  156.      * @api
  157.      */
  158.     public function setOffset($offset)
  159.     {
  160.         $this->offset = $offset;
  161.     }
  163.     /**
  164.      * Access the offset from the transport layer
  165.      *
  166.      * @return int the offset set with setOffset
  167.      */
  168.     public function getOffset()
  169.     {
  170.         return $this->offset;
  171.     }
  173.     /**
  174.      * {@inheritDoc}
  175.      *
  176.      * @api
  177.      */
  178.     public function getStatement()
  179.     {
  180.         return $this->statement;
  181.     }
  183.     /**
  184.      * {@inheritDoc}
  185.      *
  186.      * @api
  187.      */
  188.     public function getStoredQueryPath()
  189.     {
  190.         if ($this->path === null) {
  191.             throw new ItemNotFoundException('Not a stored query');
  192.         }
  194.         return $this->path;
  195.     }
  197.     /**
  198.      * {@inheritDoc}
  199.      *
  200.      * @api
  201.      */
  202.     public function storeAsNode($absPath)
  203.     {
  204.         // when implementing this, use ->getStatement***() and not $this->statement
  205.         // so this works for the extending QueryObjectModel as well
  206.         throw new UnsupportedRepositoryOperationException('Not implemented: Write');
  207.     }
  208. }