/**
* Gets the cache for the id
*
* @param string $id
* @return mixed
*/
public function get($id)
{
if (!isset($this->level1Cache[$id])) {
$this->level1Cache[$id] = $this->level2Cache->get($id);
}
return $this->level1Cache[$id];
}
/**
* Builds a data map by adding column maps for all the configured columns in the $TCA.
* It also resolves the type of values the column is holding and the typo of relation the column
* represents.
*
* @param string $className The class name you want to fetch the Data Map for
* @return \TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMap The data map
*/
public function buildDataMap($className)
{
$dataMap = $this->dataMapCache->get(str_replace('\\', '%', $className));
if ($dataMap === FALSE) {
$dataMap = $this->buildDataMapInternal($className);
$this->dataMapCache->set(str_replace('\\', '%', $className), $dataMap);
}
return $dataMap;
}
/**
* Clears cache of pages where an object with the given identifier is shown
*
* @param string $classIdentifier
* @return int|mixed
*/
public function getAutoId($classIdentifier)
{
$exclusiveLock = null;
$objectIdentifier = 'autoid-' . $classIdentifier;
$exclusiveLockAcquired = $this->acquireLock($exclusiveLock, $objectIdentifier, TRUE);
$autoId = 0;
if ($exclusiveLockAcquired) {
if ($this->trackingCache->has($objectIdentifier)) {
$autoId = $this->trackingCache->get($objectIdentifier);
}
$autoId++;
$this->trackingCache->set($objectIdentifier, $autoId);
$this->releaseLock($exclusiveLock);
}
return $autoId;
}
/**
* Finds and returns a variable value from the query cache.
*
* @param string $entryIdentifier Identifier of the cache entry to fetch
* @return mixed The value
*/
protected function getQueryCacheEntry($entryIdentifier)
{
if (!isset($this->queryRuntimeCache[$entryIdentifier])) {
$this->queryRuntimeCache[$entryIdentifier] = $this->queryCache->get($entryIdentifier);
}
return $this->queryRuntimeCache[$entryIdentifier];
}
/**
* Gets the page title of the given page id
*
* @param int $pageId
* @return string
*/
protected function getPageTitle($pageId)
{
$cacheId = 'recycler-pagetitle-' . $pageId;
if ($this->runtimeCache->has($cacheId)) {
$pageTitle = $this->runtimeCache->get($cacheId);
} else {
if ($pageId === 0) {
$pageTitle = $GLOBALS['TYPO3_CONF_VARS']['SYS']['sitename'];
} else {
$recordInfo = $this->tce->recordInfo('pages', $pageId, 'title');
$pageTitle = $recordInfo['title'];
}
$this->runtimeCache->set($cacheId, $pageTitle);
}
return $pageTitle;
}
/**
* Called by ajax.php / eID.php
* Builds an extbase context and returns the response.
*
* @return void
*/
public function dispatch()
{
$src = \TYPO3\CMS\Core\Utility\GeneralUtility::_GP('src');
$hash = \TYPO3\CMS\Core\Utility\GeneralUtility::_GP('hash');
$conf = json_decode(rawurldecode(\TYPO3\CMS\Core\Utility\GeneralUtility::_GP('conf')), true);
/* @var $cacheHash \TYPO3\CMS\Frontend\Page\CacheHashCalculator */
$cacheHash = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\Page\\CacheHashCalculator');
$calculatedHash = $cacheHash->calculateCacheHash(array('encryptionKey' => $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'], 'src' => $src, 'conf' => $conf));
$allowProcessing = $hash == $calculatedHash;
/**
* check hash
*/
if (!$allowProcessing) {
header('HTTP/1.1 503 Service Unavailable');
header('Status: 503 Service Unavailable');
exit;
}
/**
* check if source file exists
*/
if (!@file_exists($src)) {
header("HTTP/1.0 404 Not Found");
header("Status: 404 Not Found");
exit;
}
/**
* check if target file exists and is up to date
*/
if ($this->cache->has($hash)) {
list($target, $sourceMDate) = $this->cache->get($hash);
if (@file_exists($target) && @filemtime($src) === $sourceMDate) {
header("Location:" . $target);
exit;
}
}
/**
* generate image
*/
$this->initialize();
$target = $this->generateImage($src, $conf['width'], $conf['height'], $conf['minWidth'], $conf['minHeight'], $conf['maxWidth'], $conf['maxHeight']);
$sourceMDate = @filemtime($src);
$this->cache->set($hash, array($target, $sourceMDate));
header("Location:" . $target);
exit;
}
/**
* Tries to load the reflection data from this service's cache.
*
* @return void
*/
protected function loadFromCache()
{
$data = $this->dataCache->get($this->cacheIdentifier);
if ($data !== false) {
foreach ($data as $propertyName => $propertyValue) {
$this->{$propertyName} = $propertyValue;
}
}
}
/**
* @param string $id
* @return object
*/
public function findById($id)
{
$fullId = 'serialized-' . str_replace('\\', '_', get_class($this)) . '-' . $id;
$object = null;
if ($this->objectCache[$fullId]) {
$object = $this->objectCache[$fullId];
} elseif ($this->storage->has($fullId)) {
$object = $this->unserialize($this->storage->get($fullId));
$this->objectCache[$fullId] = $object;
}
return $object;
}
/**
* @param array $parameters
* @param PageLayoutView|DatabaseRecordList $caller
* @return string
*/
public function addSubIcon(array $parameters, $caller = NULL)
{
$this->attachAssets();
list($table, $uid, $record) = $parameters;
$icon = NULL;
if (NULL !== $caller) {
$record = NULL === $record && 0 < $uid ? BackendUtility::getRecord($table, $uid) : $record;
$cacheIdentity = $table . $uid . sha1(serialize($record));
// filter 1: icon must not already be cached and both record and caller must be provided.
if (TRUE === $this->cache->has($cacheIdentity)) {
$icon = $this->cache->get($cacheIdentity);
} elseif (NULL !== $record) {
$field = $this->detectFirstFlexTypeFieldInTableFromPossibilities($table, array_keys($record));
// filter 2: table must have one field defined as "flex" and record must include it.
if (NULL !== $field && TRUE === isset($record[$field])) {
// we check the cache here because at this point, the cache key is decidedly
// unique and we have not yet consulted the (potentially costly) Provider.
$provider = $this->fluxService->resolvePrimaryConfigurationProvider($table, $field, $record);
// filter 3: a Provider must be resolved for the record.
if (NULL !== $provider) {
$form = $provider->getForm((array) $record);
if (NULL !== $form) {
$icon = MiscellaneousUtility::getIconForTemplate($form);
if (NULL !== $icon) {
$label = trim($form->getLabel());
$icon = '<img width="16" height="16" src="' . $icon . '" alt="' . $label . '"
title="' . $label . '" class="" />';
$icon = sprintf($this->templates['iconWrapper'], $icon);
}
}
}
}
$this->cache->set($cacheIdentity, $icon);
}
}
return $icon;
}
/**
* Tracks display of an object on a page
*
* @param \TYPO3\CMS\Extbase\DomainObject\AbstractDomainObject $object Object to use
* @param mixed $hash Hash or page id (depending on the type) for which the object display will be associated
* @param string $type 'hash' (for only one hash) or 'id' (for complete page cache of a page, for all hash combinations)
* @return void
*/
public function trackObjectOnPage(\TYPO3\CMS\Extbase\DomainObject\AbstractDomainObject $object = NULL, $type = 'hash', $hash = false)
{
if ($object && !$this->ajaxDispatcher->getIsActive()) {
$this->signalSlotDispatcher->dispatch(__CLASS__, self::SIGNAL_PreTrackObjectOnPage, array('object' => $object, 'type' => $type, 'hash' => $hash));
if ($type) {
switch ($type) {
case 'id':
if (!$hash) {
$hash = intval($this->fe->id);
}
$pageHash = 'id-' . $hash;
break;
case 'hash':
default:
if (!$hash) {
$hash = $this->fe->getHash();
}
$pageHash = 'hash-' . $hash;
break;
}
$objectIdentifier = $this->getObjectIdentifierForObject($object);
$sharedLock = null;
$sharedLockAcquired = $this->acquireLock($sharedLock, $objectIdentifier, FALSE);
if ($sharedLockAcquired) {
if ($this->trackingCache->has($objectIdentifier)) {
$pageHashs = $this->trackingCache->get($objectIdentifier);
if (!in_array($pageHash, $pageHashs)) {
$exclusiveLock = null;
$exclusiveLockAcquired = $this->acquireLock($exclusiveLock, $objectIdentifier . '-e', TRUE);
if ($exclusiveLockAcquired) {
$pageHashs = $this->trackingCache->get($objectIdentifier);
if (!in_array($pageHash, $pageHashs)) {
$pageHashs[] = $pageHash;
$this->trackingCache->set($objectIdentifier, array_unique($pageHashs));
}
$this->releaseLock($exclusiveLock);
}
}
} else {
$this->trackingCache->set($objectIdentifier, array($pageHash));
}
$this->releaseLock($sharedLock);
}
}
}
return;
}
/**
* Hook for generating dynamic FlexForm source code.
*
* NOTE: patches data structure resolving in a way that solves
* a regression in the TYPO3 core when dealing with IRRE AJAX
* requests (in which the database record is no longer fetched
* by the controller). This patches not only data structure
* resolving for Flux data structures but indeed any data
* structure built using hooks or involving user functions which
* require the entire record (but when using hooks, supports
* only extensions which are loaded AFTER or depend on Flux).
*
* @param array $dataStructArray
* @param array $conf
* @param array $row
* @param string $table
* @param string $fieldName
* @return void
*/
public function getFlexFormDS_postProcessDS(&$dataStructArray, $conf, &$row, $table, $fieldName)
{
if (empty($fieldName) === TRUE) {
// Cast NULL if an empty but not-NULL field name was passed. This has significance to the Flux internals in
// respect to which ConfigurationProvider(s) are returned.
$fieldName = NULL;
}
if (!empty($fieldName) && !isset($row[$fieldName])) {
// Patch required (possibly temporary). Due to changes in TYPO3 in the new FormEngine we must fetch the
// database record at this point when the record is incomplete, which happens when attempting to render
// IRRE records. The reason is that the controller that creates the HTML does not fetch the record any
// more - and that the AJAX request contains only the UID. So, we fetch the record here to ensure it
// contains the necessary fields. DOES NOT WORK FOR NEW RECORDS - SEE COMMENTS BELOW.
$row = $this->recordService->getSingle($table, '*', $row['uid']);
}
$defaultDataSourceCacheIdentifier = $table . '_' . $fieldName . '_' . sha1(serialize($conf));
if (!$row) {
// In the case that the database record cannot be fetched we are dealing with a new or otherwise deleted
// or unidentifiable record. This happens primarily when AJAX requests are made to render IRRE records
// without the parent record having been saved first. To accommodate this case we have to be slightly
// creative and store a "default" data source definition which is identified based on a checksum of the
// configuration provided. Whenever we are then unable to fetch a record, we can at least attempt to
// locate a default data source in previously cached content. NB: we enforce a VERY high cache lifetime
// and continually refresh it every time it is possible to render a new DS that can serve as default.
$dataStructArray = (array) $this->cache->get($defaultDataSourceCacheIdentifier);
} else {
if (FALSE === is_array($dataStructArray)) {
$dataStructArray = array();
}
$providers = $this->configurationService->resolveConfigurationProviders($table, $fieldName, $row);
foreach ($providers as $provider) {
$provider->postProcessDataStructure($row, $dataStructArray, $conf);
}
if (empty($dataStructArray)) {
$dataStructArray = array('ROOT' => array('el' => array()));
}
$evaluationParameters = array();
$this->cache->set($defaultDataSourceCacheIdentifier, $this->recursivelyEvaluateClosures($dataStructArray, $evaluationParameters), array(), time() + 31536000);
}
// Trigger TCEforms dimension patching only if required by TYPO3 version according to CompatibilityRegistry.
if (CompatibilityRegistry::get('FluidTYPO3\\Flux\\Backend\\DynamicFlexForm::NEEDS_TCEFORMS_WRAPPER')) {
$dataStructArray = $this->patchTceformsWrapper($dataStructArray);
}
}
/**
* Builds the page ID checking statement
*
* @param string $tableName The database table name
* @param array &$sql The query parts
* @param array $storagePageIds list of storage page ids
* @throws \TYPO3\CMS\Extbase\Persistence\Generic\Exception\InconsistentQuerySettingsException
* @return void
*/
protected function addPageIdStatement($tableName, array &$sql, array $storagePageIds)
{
$tableColumns = $this->tableColumnCache->get($tableName);
if ($tableColumns === FALSE) {
$tableColumns = $this->databaseHandle->admin_get_fields($tableName);
$this->tableColumnCache->set($tableName, $tableColumns);
}
if (is_array($GLOBALS['TCA'][$tableName]['ctrl']) && array_key_exists('pid', $tableColumns)) {
$rootLevel = (int) $GLOBALS['TCA'][$tableName]['ctrl']['rootLevel'];
if ($rootLevel) {
if ($rootLevel === 1) {
$sql['additionalWhereClause'][] = $tableName . '.pid = 0';
}
} else {
if (empty($storagePageIds)) {
throw new \TYPO3\CMS\Extbase\Persistence\Generic\Exception\InconsistentQuerySettingsException('Missing storage page ids.', 1365779762);
}
$sql['additionalWhereClause'][] = $tableName . '.pid IN (' . implode(', ', $storagePageIds) . ')';
}
}
}
/**
* Builds the page ID checking statement
*
* @param string $tableName The database table name
* @param string $tableAlias The table alias used in the query.
* @param array $storagePageIds list of storage page ids
* @throws InconsistentQuerySettingsException
* @return string
*/
protected function getPageIdStatement($tableName, $tableAlias, array $storagePageIds)
{
$pageIdStatement = '';
$tableColumns = $this->tableColumnCache->get($tableName);
if ($tableColumns === false) {
$tableColumns = $this->databaseHandle->admin_get_fields($tableName);
$this->tableColumnCache->set($tableName, $tableColumns);
}
if (is_array($GLOBALS['TCA'][$tableName]['ctrl']) && array_key_exists('pid', $tableColumns)) {
$rootLevel = (int) $GLOBALS['TCA'][$tableName]['ctrl']['rootLevel'];
switch ($rootLevel) {
// Only in pid 0
case 1:
return $tableAlias . '.pid = 0';
// Pid 0 and pagetree
// Pid 0 and pagetree
case -1:
if (empty($storagePageIds)) {
return $tableAlias . '.pid = 0';
}
$storagePageIds[] = 0;
break;
// Only pagetree or not set
// Only pagetree or not set
case 0:
if (empty($storagePageIds)) {
throw new InconsistentQuerySettingsException('Missing storage page ids.', 1365779762);
}
break;
// Invalid configuration
// Invalid configuration
default:
return '';
}
$pageIdStatement = $tableAlias . '.pid IN (' . implode(',', $this->databaseHandle->cleanIntArray($storagePageIds)) . ')';
}
return $pageIdStatement;
}
/**
* Returns array of arrays with an index of all references found in record from table/uid
* If the result is used to update the sys_refindex table then ->WSOL must NOT be TRUE (no workspace overlay anywhere!)
*
* @param string $tableName Table name from $GLOBALS['TCA']
* @param int $uid Record UID
* @return array|NULL Index Rows
* @todo Define visibility
*/
public function generateRefIndexData($tableName, $uid)
{
if (!isset($GLOBALS['TCA'][$tableName])) {
return NULL;
}
$this->relations = array();
// Fetch tableRelationFields and save them in cache if not there yet
$cacheId = static::$cachePrefixTableRelationFields . $tableName;
if (!$this->runtimeCache->has($cacheId)) {
$tableRelationFields = $this->fetchTableRelationFields($tableName);
$this->runtimeCache->set($cacheId, $tableRelationFields);
} else {
$tableRelationFields = $this->runtimeCache->get($cacheId);
}
// Return if there are no fields which could contain relations
if ($tableRelationFields === '') {
return $this->relations;
}
$deleteField = $GLOBALS['TCA'][$tableName]['ctrl']['delete'];
if ($tableRelationFields === '*') {
// If one field of a record is of type flex, all fields have to be fetched to be passed to BackendUtility::getFlexFormDS
$selectFields = '*';
} else {
// otherwise only fields that might contain relations are fetched
$selectFields = 'uid,' . $tableRelationFields . ($deleteField ? ',' . $deleteField : '');
}
// Get raw record from DB:
$record = $GLOBALS['TYPO3_DB']->exec_SELECTgetSingleRow($selectFields, $tableName, 'uid=' . (int) $uid);
if (!is_array($record)) {
return NULL;
}
// Initialize:
$this->words_strings = array();
$this->words = array();
// Deleted:
$deleted = $deleteField && $record[$deleteField] ? 1 : 0;
// Get all relations from record:
$recordRelations = $this->getRelations($tableName, $record);
// Traverse those relations, compile records to insert in table:
foreach ($recordRelations as $fieldName => $fieldRelations) {
// Based on type,
switch ((string) $fieldRelations['type']) {
case 'db':
$this->createEntryData_dbRels($tableName, $uid, $fieldName, '', $deleted, $fieldRelations['itemArray']);
break;
case 'file_reference':
// not used (see getRelations()), but fallback to file
// not used (see getRelations()), but fallback to file
case 'file':
$this->createEntryData_fileRels($tableName, $uid, $fieldName, '', $deleted, $fieldRelations['newValueFiles']);
break;
case 'flex':
// DB references:
if (is_array($fieldRelations['flexFormRels']['db'])) {
foreach ($fieldRelations['flexFormRels']['db'] as $flexPointer => $subList) {
$this->createEntryData_dbRels($tableName, $uid, $fieldName, $flexPointer, $deleted, $subList);
}
}
// File references in flexforms
// @todo #65463 Test correct handling of file references in flexforms
if (is_array($fieldRelations['flexFormRels']['file'])) {
foreach ($fieldRelations['flexFormRels']['file'] as $flexPointer => $subList) {
$this->createEntryData_fileRels($tableName, $uid, $fieldName, $flexPointer, $deleted, $subList);
}
}
// Soft references in flexforms
// @todo #65464 Test correct handling of soft references in flexforms
if (is_array($fieldRelations['flexFormRels']['softrefs'])) {
foreach ($fieldRelations['flexFormRels']['softrefs'] as $flexPointer => $subList) {
$this->createEntryData_softreferences($tableName, $uid, $fieldName, $flexPointer, $deleted, $subList['keys']);
}
}
break;
}
// Soft references in the field:
if (is_array($fieldRelations['softrefs'])) {
$this->createEntryData_softreferences($tableName, $uid, $fieldName, '', $deleted, $fieldRelations['softrefs']['keys']);
}
}
return $this->relations;
}
/**
* @param string $extensionKey
* @param string $version
* @param array $segments
* @return array
*/
protected function getSchemaData($extensionKey, $version, $segments)
{
if (FALSE === ExtensionManagementUtility::isLoaded($extensionKey)) {
return array();
}
$baseCacheKey = $extensionKey . $version;
$baseCacheKey = preg_replace('/[^a-z0-9]+/i', '-', $baseCacheKey);
$cacheKey = $baseCacheKey . implode('', $segments);
if (TRUE === $this->cache->has($cacheKey)) {
return $this->cache->get($cacheKey);
}
$className = implode('/', $segments);
$url = GeneralUtility::getIndpEnv('TYPO3_REQUEST_URL');
$schemaFile = $this->getXsdStoragePathSetting() . $extensionKey . '-' . $version . '.xsd';
$schemaFile = GeneralUtility::getFileAbsFileName($schemaFile);
$schemaSource = shell_exec('cat ' . $schemaFile . ' | tr -cd \'[:print:]\\r\\n\\t\'');
$document = new \DOMDocument();
$document->validateOnParse = TRUE;
$document->strictErrorChecking = TRUE;
$document->loadXML($schemaSource);
if (TRUE === $this->cache->has($baseCacheKey . 'tree')) {
$tree = $this->cache->get($baseCacheKey . 'tree');
} else {
$tree = $this->buildTreeFromSchema($document);
$this->cache->set($baseCacheKey . 'tree', $tree);
}
$node = $this->findCurrentViewHelperNode($document, $segments);
$targetNamespaceUrl = $document->documentElement->getAttribute('targetNamespace');
if (0 < count($segments)) {
$viewHelperArguments = $this->makeArgumentDefinitions($node, $extensionKey, $className);
$docComment = $node->getElementsByTagName('documentation')->item(0)->nodeValue;
$additionalDocumentationFile = ExtensionManagementUtility::extPath($extensionKey, 'Documentation/Classes/ViewHelpers/' . $className . '/README.md');
$nextDiv = FALSE;
if (TRUE === file_exists($additionalDocumentationFile)) {
$alerts = array('warning', 'danger', 'success', 'info');
$additionalDocumentation = file_get_contents($additionalDocumentationFile);
$parts = explode('```', $additionalDocumentation);
foreach ($parts as $index => &$part) {
$firstText = substr($part, 0, strpos($part, LF));
if (TRUE === in_array($firstText, $alerts)) {
$part = '<span class="alert alert-' . $firstText . '"><span class="lead">' . ucfirst($firstText) . '</span><br />' . substr($part, strlen($firstText));
$nextDiv = TRUE;
} else {
if (TRUE === $nextDiv) {
$part = '</span>' . $part;
$nextDiv = FALSE;
} elseif (0 < $index) {
$part = '```' . $part;
}
}
}
$additionalDocumentation = implode('', $parts);
$additionalDocumentation = preg_replace('/Arguments\\/([a-z0-9^\\s\\/]+)\\.md/i', $url . '#argument-$1', $additionalDocumentation);
$additionalDocumentation = preg_replace('/(```)([a-z\\s]+)(.[\\`]{3})(```)/i', $url . '<div class="alert alert-$1">$2</div>', $additionalDocumentation);
$docComment .= LF . LF . $additionalDocumentation;
}
}
$data = array($tree, $node, $viewHelperArguments, $docComment, $targetNamespaceUrl);
$this->cache->set($cacheKey, $data);
return $data;
}
/**
* Registers elements to be deleted in the registry.
*
* @return void
* @see process_datamap
*/
protected function registerElementsToBeDeleted()
{
$elementsToBeDeleted = (array) $this->runtimeCache->get('core-datahandler-elementsToBeDeleted');
$this->runtimeCache->set('core-datahandler-elementsToBeDeleted', array_merge($elementsToBeDeleted, $this->getCommandMapElements('delete')));
}
/**
* Creates a SELECT prepared SQL statement.
*
* @param string $select_fields See exec_SELECTquery()
* @param string $from_table See exec_SELECTquery()
* @param string $where_clause See exec_SELECTquery()
* @param string $groupBy See exec_SELECTquery()
* @param string $orderBy See exec_SELECTquery()
* @param string $limit See exec_SELECTquery()
* @param array $input_parameters An array of values with as many elements as there are bound parameters in the SQL statement being executed. All values are treated as \TYPO3\CMS\Core\Database\PreparedStatement::PARAM_AUTOTYPE.
* @return \TYPO3\CMS\Core\Database\PreparedStatement Prepared statement
*/
public function prepare_SELECTquery($select_fields, $from_table, $where_clause, $groupBy = '', $orderBy = '', $limit = '', array $input_parameters = array())
{
$pt = $this->debug ? GeneralUtility::milliseconds() : 0;
$precompiledParts = array();
if ($this->queryCache) {
$cacheKey = 'prepare_SELECTquery-' . \TYPO3\CMS\Dbal\QueryCache::getCacheKey(array('selectFields' => $select_fields, 'fromTable' => $from_table, 'whereClause' => $where_clause, 'groupBy' => $groupBy, 'orderBy' => $orderBy, 'limit' => $limit));
if ($this->queryCache->has($cacheKey)) {
$precompiledParts = $this->queryCache->get($cacheKey);
if ($this->debug) {
$data = array('args' => array($from_table, $select_fields, $where_clause, $groupBy, $orderBy, $limit, $input_parameters), 'precompiledParts' => $precompiledParts);
$this->debugHandler('prepare_SELECTquery (cache hit)', GeneralUtility::milliseconds() - $pt, $data);
}
}
}
$ORIG_tableName = '';
if (empty($precompiledParts)) {
// Map table / field names if needed:
$ORIG_tableName = $from_table;
// Saving table names in $ORIG_from_table since $from_table is transformed beneath:
$parsedFromTable = array();
$queryComponents = array();
if ($tableArray = $this->map_needMapping($ORIG_tableName, FALSE, $parsedFromTable)) {
$from = $parsedFromTable ? $parsedFromTable : $from_table;
$components = $this->map_remapSELECTQueryParts($select_fields, $from, $where_clause, $groupBy, $orderBy);
$queryComponents['SELECT'] = $components[0];
$queryComponents['FROM'] = $components[1];
$queryComponents['WHERE'] = $components[2];
$queryComponents['GROUPBY'] = $components[3];
$queryComponents['ORDERBY'] = $components[4];
$queryComponents['parameters'] = $components[5];
} else {
$queryComponents = $this->getQueryComponents($select_fields, $from_table, $where_clause, $groupBy, $orderBy, $limit);
}
$queryComponents['ORIG_tableName'] = $ORIG_tableName;
if (!$this->runningNative()) {
// Quotes all fields
$queryComponents['SELECT'] = $this->_quoteFieldNames($queryComponents['SELECT']);
$queryComponents['FROM'] = $this->_quoteFromTables($queryComponents['FROM']);
$queryComponents['WHERE'] = $this->_quoteWhereClause($queryComponents['WHERE']);
$queryComponents['GROUPBY'] = $this->_quoteGroupBy($queryComponents['GROUPBY']);
$queryComponents['ORDERBY'] = $this->_quoteOrderBy($queryComponents['ORDERBY']);
}
$precompiledParts = $this->precompileSELECTquery($queryComponents);
if ($this->queryCache) {
try {
$this->queryCache->set($cacheKey, $precompiledParts);
} catch (\TYPO3\CMS\Core\Cache\Exception $e) {
if ($this->debug) {
GeneralUtility::devLog($e->getMessage(), 'dbal', 1);
}
}
}
}
$preparedStatement = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Database\PreparedStatement::class, '', $from_table, $precompiledParts);
/* @var $preparedStatement \TYPO3\CMS\Core\Database\PreparedStatement */
// Bind values to parameters
foreach ($input_parameters as $key => $value) {
$preparedStatement->bindValue($key, $value, \TYPO3\CMS\Core\Database\PreparedStatement::PARAM_AUTOTYPE);
}
if ($this->debug) {
$data = array('args' => array($from_table, $select_fields, $where_clause, $groupBy, $orderBy, $limit, $input_parameters), 'ORIG_from_table' => $ORIG_tableName);
$this->debugHandler('prepare_SELECTquery', GeneralUtility::milliseconds() - $pt, $data);
}
// Return prepared statement
return $preparedStatement;
}
