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

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. * @return \PHPCR\Query\QueryResultInterface a QueryResult object
  99. *
  100. * @api
  101. */
  102. public function execute()
  103. {
  104. if (null === $this->objectManager) {
  105. // if the ObjectManager was not injected in the header. this is only supposed to happen in the DBAL client.
  106. throw new RepositoryException('Jackalope implementation error: This query was built for parsing only. (There is no ObjectManager to run the query against.)');
  107. }
  108. $transport = $this->objectManager->getTransport();
  109. $rawData = $transport->query($this);
  110. $queryResult = $this->factory->get(QueryResult::class, [$rawData, $this->objectManager]);
  112. return $queryResult;
  113. }
  115. /**
  116. * {@inheritDoc}
  117. *
  118. * @return bool true if the query was executing and will be cancelled,
  119. * or false if the query cannot not be cancelled because it has either
  120. * already finished executing, it has already been cancelled, or the
  121. * implementation does not support canceling queries
  122. *
  123. * @api
  124. */
  125. public function cancel()
  126. {
  127. return false;
  128. }
  130. /**
  131. * {@inheritDoc}
  132. *
  133. * @return string[]
  134. *
  135. * @api
  136. */
  137. public function getBindVariableNames()
  138. {
  139. throw new RepositoryException('Not Implemented...');
  140. }
  142. /**
  143. * {@inheritDoc}
  144. *
  145. * @api
  146. */
  147. public function setLimit($limit)
  148. {
  149. $this->limit = $limit;
  150. }
  152. /**
  153. * Access the limit from the transport layer
  154. *
  155. * @return int the limit set with setLimit
  156. */
  157. public function getLimit()
  158. {
  159. return $this->limit;
  160. }
  162. /**
  163. * {@inheritDoc}
  164. *
  165. * @api
  166. */
  167. public function setOffset($offset)
  168. {
  169. $this->offset = $offset;
  170. }
  172. /**
  173. * Access the offset from the transport layer
  174. *
  175. * @return int the offset set with setOffset
  176. */
  177. public function getOffset()
  178. {
  179. return $this->offset;
  180. }
  182. /**
  183. * {@inheritDoc}
  184. *
  185. * @return string the query statement
  186. *
  187. * @api
  188. */
  189. public function getStatement()
  190. {
  191. return $this->statement;
  192. }
  194. /**
  195. * {@inheritDoc}
  196. *
  197. * @return string path of the node representing this query
  198. *
  199. * @api
  200. */
  201. public function getStoredQueryPath()
  202. {
  203. if ($this->path === null) {
  204. throw new ItemNotFoundException('Not a stored query');
  205. }
  207. return $this->path;
  208. }
  210. /**
  211. * {@inheritDoc}
  212. *
  213. * @return \PHPCR\NodeInterface the newly created node
  214. *
  215. * @api
  216. */
  217. public function storeAsNode($absPath)
  218. {
  219. // when implementing this, use ->getStatement***() and not $this->statement
  220. // so this works for the extending QueryObjectModel as well
  221. throw new UnsupportedRepositoryOperationException('Not implemented: Write');
  222. }
  223. }