vendor/contao/core-bundle/src/Resources/contao/library/Contao/DcaExtractor.php line 106

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of Contao.
  5. *
  6. * (c) Leo Feyer
  7. *
  8. * @license LGPL-3.0-or-later
  9. */
  11. namespace Contao;
  13. use Symfony\Component\Config\Exception\FileLocatorFileNotFoundException;
  15. /**
  16. * Extracts DCA information and cache it
  17. *
  18. * The class parses the DCA files and stores various extracts like relations
  19. * in the cache directory. This metadata can then be loaded and used in the
  20. * application (e.g. the Model classes).
  21. *
  22. * Usage:
  23. *
  24. * $user = DcaExtractor::getInstance('tl_user');
  25. *
  26. * if ($user->hasRelations())
  27. * {
  28. * print_r($user->getRelations());
  29. * }
  30. */
  31. class DcaExtractor extends Controller
  32. {
  33. /**
  34. * Instances
  35. * @var DcaExtractor[]
  36. */
  37. protected static $arrInstances = array();
  39. /**
  40. * Table name
  41. * @var string
  42. */
  43. protected $strTable;
  45. /**
  46. * Metadata
  47. * @var array
  48. */
  49. protected $arrMeta = array();
  51. /**
  52. * Fields
  53. * @var array
  54. */
  55. protected $arrFields = array();
  57. /**
  58. * Order fields
  59. * @var array
  60. */
  61. protected $arrOrderFields = array();
  63. /**
  64. * Unique fields
  65. * @var array
  66. */
  67. protected $arrUniqueFields = array();
  69. /**
  70. * Keys
  71. * @var array
  72. */
  73. protected $arrKeys = array();
  75. /**
  76. * Relations
  77. * @var array
  78. */
  79. protected $arrRelations = array();
  81. /**
  82. * SQL buffer
  83. * @var array
  84. */
  85. protected static $arrSql = array();
  87. /**
  88. * Database table
  89. * @var boolean
  90. */
  91. protected $blnIsDbTable = false;
  93. /**
  94. * database.sql file paths
  95. * @var array|null
  96. */
  97. private static $arrDatabaseSqlFiles;
  99. /**
  100. * Load or create the extract
  101. *
  102. * @param string $strTable The table name
  103. *
  104. * @throws \Exception If $strTable is empty
  105. */
  106. protected function __construct($strTable)
  107. {
  108. if (!$strTable)
  109. {
  110. throw new \Exception('The table name must not be empty');
  111. }
  113. parent::__construct();
  115. $this->strTable = $strTable;
  117. $strFile = System::getContainer()->getParameter('kernel.cache_dir') . '/contao/sql/' . $strTable . '.php';
  119. // Try to load from cache
  120. if (file_exists($strFile))
  121. {
  122. include $strFile;
  123. }
  124. else
  125. {
  126. $this->createExtract();
  127. }
  128. }
  130. /**
  131. * Prevent cloning of the object (Singleton)
  132. */
  133. final public function __clone()
  134. {
  135. }
  137. /**
  138. * Get one object instance per table
  139. *
  140. * @param string $strTable The table name
  141. *
  142. * @return DcaExtractor The object instance
  143. */
  144. public static function getInstance($strTable)
  145. {
  146. if (!isset(static::$arrInstances[$strTable]))
  147. {
  148. static::$arrInstances[$strTable] = new static($strTable);
  149. }
  151. return static::$arrInstances[$strTable];
  152. }
  154. /**
  155. * Return the metadata as array
  156. *
  157. * @return array The metadata
  158. */
  159. public function getMeta()
  160. {
  161. return $this->arrMeta;
  162. }
  164. /**
  165. * Return true if there is metadata
  166. *
  167. * @return boolean True if there is metadata
  168. */
  169. public function hasMeta()
  170. {
  171. return !empty($this->arrMeta);
  172. }
  174. /**
  175. * Return the fields as array
  176. *
  177. * @return array The fields array
  178. */
  179. public function getFields()
  180. {
  181. return $this->arrFields;
  182. }
  184. /**
  185. * Return true if there are fields
  186. *
  187. * @return boolean True if there are fields
  188. */
  189. public function hasFields()
  190. {
  191. return !empty($this->arrFields);
  192. }
  194. /**
  195. * Return the order fields as array
  196. *
  197. * @return array The order fields array
  198. */
  199. public function getOrderFields()
  200. {
  201. return $this->arrOrderFields;
  202. }
  204. /**
  205. * Return true if there are order fields
  206. *
  207. * @return boolean True if there are order fields
  208. */
  209. public function hasOrderFields()
  210. {
  211. return !empty($this->arrOrderFields);
  212. }
  214. /**
  215. * Return an array of unique columns
  216. *
  217. * @return array
  218. */
  219. public function getUniqueFields()
  220. {
  221. return $this->arrUniqueFields;
  222. }
  224. /**
  225. * Return true if there are unique fields
  226. *
  227. * @return boolean True if there are unique fields
  228. */
  229. public function hasUniqueFields()
  230. {
  231. return !empty($this->arrUniqueFields);
  232. }
  234. /**
  235. * Return the keys as array
  236. *
  237. * @return array The keys array
  238. */
  239. public function getKeys()
  240. {
  241. return $this->arrKeys;
  242. }
  244. /**
  245. * Return true if there are keys
  246. *
  247. * @return boolean True if there are keys
  248. */
  249. public function hasKeys()
  250. {
  251. return !empty($this->arrKeys);
  252. }
  254. /**
  255. * Return the relations as array
  256. *
  257. * @return array The relations array
  258. */
  259. public function getRelations()
  260. {
  261. return $this->arrRelations;
  262. }
  264. /**
  265. * Return true if there are relations
  266. *
  267. * @return boolean True if there are relations
  268. */
  269. public function hasRelations()
  270. {
  271. return !empty($this->arrRelations);
  272. }
  274. /**
  275. * Return true if the extract relates to a database table
  276. *
  277. * @return boolean True if the extract relates to a database table
  278. */
  279. public function isDbTable()
  280. {
  281. return $this->blnIsDbTable;
  282. }
  284. /**
  285. * Return an array that can be used by the database installer
  286. *
  287. * @return array The data array
  288. */
  289. public function getDbInstallerArray()
  290. {
  291. $return = array();
  293. // Fields
  294. foreach ($this->arrFields as $k=>$v)
  295. {
  296. if (\is_array($v))
  297. {
  298. if (!isset($v['name']))
  299. {
  300. $v['name'] = $k;
  301. }
  303. $return['SCHEMA_FIELDS'][$k] = $v;
  304. }
  305. else
  306. {
  307. $return['TABLE_FIELDS'][$k] = '`' . $k . '` ' . $v;
  308. }
  309. }
  311. $quote = static function ($item) { return '`' . $item . '`'; };
  313. // Keys
  314. foreach ($this->arrKeys as $k=>$v)
  315. {
  316. // Handle multi-column indexes (see #5556)
  317. if (strpos($k, ',') !== false)
  318. {
  319. $f = array_map($quote, StringUtil::trimsplit(',', $k));
  320. $k = str_replace(',', '_', $k);
  321. }
  322. else
  323. {
  324. $f = array($quote($k));
  325. }
  327. if ($v == 'primary')
  328. {
  329. $k = 'PRIMARY';
  330. $v = 'PRIMARY KEY (' . implode(', ', $f) . ')';
  331. }
  332. elseif ($v == 'index')
  333. {
  334. $v = 'KEY `' . $k . '` (' . implode(', ', $f) . ')';
  335. }
  336. else
  337. {
  338. $v = strtoupper($v) . ' KEY `' . $k . '` (' . implode(', ', $f) . ')';
  339. }
  341. $return['TABLE_CREATE_DEFINITIONS'][$k] = $v;
  342. }
  344. $return['TABLE_OPTIONS'] = '';
  346. // Options
  347. foreach ($this->arrMeta as $k=>$v)
  348. {
  349. if ($k == 'engine')
  350. {
  351. $return['TABLE_OPTIONS'] .= ' ENGINE=' . $v;
  352. }
  353. elseif ($k == 'charset')
  354. {
  355. $return['TABLE_OPTIONS'] .= ' DEFAULT CHARSET=' . $v;
  356. }
  357. elseif ($k == 'collate')
  358. {
  359. $return['TABLE_OPTIONS'] .= ' COLLATE ' . $v;
  360. }
  361. }
  363. return $return;
  364. }
  366. /**
  367. * Create the extract from the DCA or the database.sql files
  368. */
  369. protected function createExtract()
  370. {
  371. // Load the default language file (see #7202)
  372. if (empty($GLOBALS['TL_LANG']['MSC']))
  373. {
  374. System::loadLanguageFile('default');
  375. }
  377. // Load the data container
  378. $this->loadDataContainer($this->strTable);
  380. // Return if the table is not defined
  381. if (!isset($GLOBALS['TL_DCA'][$this->strTable]))
  382. {
  383. return;
  384. }
  386. // Return if the DC type is "File"
  387. if (is_a(DataContainer::getDriverForTable($this->strTable), DC_File::class, true))
  388. {
  389. return;
  390. }
  392. // Return if the DC type is "Folder" and the DC is not database assisted
  393. if (is_a(DataContainer::getDriverForTable($this->strTable), DC_Folder::class, true) && empty($GLOBALS['TL_DCA'][$this->strTable]['config']['databaseAssisted']))
  394. {
  395. return;
  396. }
  398. $blnFromFile = false;
  399. $arrRelations = array();
  401. // Check whether there are fields (see #4826)
  402. if (isset($GLOBALS['TL_DCA'][$this->strTable]['fields']))
  403. {
  404. foreach ($GLOBALS['TL_DCA'][$this->strTable]['fields'] as $field=>$config)
  405. {
  406. // Check whether all fields have an SQL definition
  407. if (!\array_key_exists('sql', $config) && isset($config['inputType']))
  408. {
  409. $blnFromFile = true;
  410. }
  412. // Check whether there is a relation (see #6524)
  413. if (isset($config['relation']))
  414. {
  415. $table = null;
  417. if (isset($config['foreignKey']))
  418. {
  419. $table = explode('.', $config['foreignKey'])[0];
  420. }
  422. $arrRelations[$field] = array_merge(array('table'=>$table, 'field'=>'id'), $config['relation']);
  424. // Store the field delimiter if the related IDs are stored in CSV format (see #257)
  425. if (isset($config['eval']['csv']))
  426. {
  427. $arrRelations[$field]['delimiter'] = $config['eval']['csv'];
  428. }
  430. // Table name and field name are mandatory
  431. if (empty($arrRelations[$field]['table']) || empty($arrRelations[$field]['field']))
  432. {
  433. throw new \Exception('Incomplete relation defined for ' . $this->strTable . '.' . $field);
  434. }
  435. }
  436. }
  437. }
  439. $sql = $GLOBALS['TL_DCA'][$this->strTable]['config']['sql'] ?? array();
  440. $fields = $GLOBALS['TL_DCA'][$this->strTable]['fields'] ?? array();
  442. // Deprecated since Contao 4.0, to be removed in Contao 5.0
  443. if ($blnFromFile && !empty($files = $this->getDatabaseSqlFiles()))
  444. {
  445. trigger_deprecation('contao/core-bundle', '4.0', 'Using "database.sql" files has been deprecated and will no longer work in Contao 5.0. Use a DCA file instead.');
  447. if (!isset(static::$arrSql[$this->strTable]))
  448. {
  449. $arrSql = array();
  451. foreach ($files as $file)
  452. {
  453. $arrSql = array_merge_recursive($arrSql, SqlFileParser::parse($file));
  454. }
  456. static::$arrSql = $arrSql;
  457. }
  459. $arrTable = static::$arrSql[$this->strTable] ?? array();
  460. $engine = null;
  461. $charset = null;
  463. if (isset($arrTable['TABLE_OPTIONS']))
  464. {
  465. if (\is_array($arrTable['TABLE_OPTIONS']))
  466. {
  467. $arrTable['TABLE_OPTIONS'] = $arrTable['TABLE_OPTIONS'][0]; // see #324
  468. }
  470. $chunks = explode(' ', trim($arrTable['TABLE_OPTIONS']));
  472. if (isset($chunks[0]))
  473. {
  474. $engine = $chunks[0];
  475. }
  477. if (isset($chunks[2]))
  478. {
  479. $charset = $chunks[2];
  480. }
  481. }
  483. if ($engine)
  484. {
  485. $sql['engine'] = str_replace('ENGINE=', '', $engine);
  486. }
  488. if ($charset)
  489. {
  490. $sql['charset'] = str_replace('CHARSET=', '', $charset);
  491. }
  493. // Fields
  494. if (isset($arrTable['TABLE_FIELDS']))
  495. {
  496. foreach ($arrTable['TABLE_FIELDS'] as $k=>$v)
  497. {
  498. $fields[$k]['sql'] = str_replace('`' . $k . '` ', '', $v);
  499. }
  500. }
  502. // Keys
  503. if (isset($arrTable['TABLE_CREATE_DEFINITIONS']))
  504. {
  505. foreach ($arrTable['TABLE_CREATE_DEFINITIONS'] as $strKey)
  506. {
  507. if (preg_match('/^([A-Z]+ )?KEY .+\(([^)]+)\)$/', $strKey, $arrMatches) && preg_match_all('/`([^`]+)`/', $arrMatches[2], $arrFields))
  508. {
  509. $type = trim($arrMatches[1]);
  510. $field = implode(',', $arrFields[1]);
  511. $sql['keys'][$field] = $type ? strtolower($type) : 'index';
  512. }
  513. }
  514. }
  515. }
  517. // Relations
  518. if (!empty($arrRelations))
  519. {
  520. $this->arrRelations = array();
  522. foreach ($arrRelations as $field=>$config)
  523. {
  524. $this->arrRelations[$field] = array();
  526. foreach ($config as $k=>$v)
  527. {
  528. $this->arrRelations[$field][$k] = $v;
  529. }
  530. }
  531. }
  533. // Not a database table or no field information
  534. if (empty($sql) || empty($fields))
  535. {
  536. return;
  537. }
  539. $params = System::getContainer()->get('database_connection')->getParams();
  541. // Add the default engine and charset if none is given
  542. if (empty($sql['engine']))
  543. {
  544. $sql['engine'] = $params['defaultTableOptions']['engine'] ?? 'InnoDB';
  545. }
  547. if (empty($sql['charset']))
  548. {
  549. $sql['charset'] = $params['defaultTableOptions']['charset'] ?? 'utf8mb4';
  550. }
  552. if (empty($sql['collate']))
  553. {
  554. $sql['collate'] = $params['defaultTableOptions']['collate'] ?? 'utf8mb4_unicode_ci';
  555. }
  557. // Meta
  558. $this->arrMeta = array
  559. (
  560. 'engine' => $sql['engine'],
  561. 'charset' => $sql['charset'],
  562. 'collate' => $sql['collate']
  563. );
  565. // Fields
  566. $this->arrFields = array();
  567. $this->arrOrderFields = array();
  569. // Fields
  570. foreach ($fields as $field=>$config)
  571. {
  572. if (isset($config['sql']))
  573. {
  574. $this->arrFields[$field] = $config['sql'];
  575. }
  577. // Only add order fields of binary fields (see #7785)
  578. if (isset($config['inputType'], $config['eval']['orderField']) && $config['inputType'] == 'fileTree')
  579. {
  580. $this->arrOrderFields[] = $config['eval']['orderField'];
  581. }
  583. if (isset($config['eval']['unique']) && $config['eval']['unique'])
  584. {
  585. $this->arrUniqueFields[] = $field;
  586. }
  587. }
  589. // Keys
  590. if (!empty($sql['keys']) && \is_array($sql['keys']))
  591. {
  592. $this->arrKeys = array();
  594. foreach ($sql['keys'] as $field=>$type)
  595. {
  596. $this->arrKeys[$field] = $type;
  598. if ($type == 'unique')
  599. {
  600. $this->arrUniqueFields[] = $field;
  601. }
  602. }
  603. }
  605. $this->arrUniqueFields = array_unique($this->arrUniqueFields);
  606. $this->blnIsDbTable = true;
  607. }
  609. private function getDatabaseSqlFiles(): array
  610. {
  611. if (null !== self::$arrDatabaseSqlFiles)
  612. {
  613. return self::$arrDatabaseSqlFiles;
  614. }
  616. try
  617. {
  618. $files = System::getContainer()->get('contao.resource_locator')->locate('config/database.sql', null, false);
  619. }
  620. catch (FileLocatorFileNotFoundException $e)
  621. {
  622. $files = array();
  623. }
  625. return self::$arrDatabaseSqlFiles = $files;
  626. }
  627. }
  629. class_alias(DcaExtractor::class, 'DcaExtractor');