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

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 meta data 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.  * @author Leo Feyer <https://github.com/leofeyer>
  32.  */
  33. class DcaExtractor extends Controller
  34. {
  35.     /**
  36.      * Instances
  37.      * @var DcaExtractor[]
  38.      */
  39.     protected static $arrInstances = array();
  41.     /**
  42.      * Table name
  43.      * @var string
  44.      */
  45.     protected $strTable;
  47.     /**
  48.      * Meta data
  49.      * @var array
  50.      */
  51.     protected $arrMeta = array();
  53.     /**
  54.      * Fields
  55.      * @var array
  56.      */
  57.     protected $arrFields = array();
  59.     /**
  60.      * Order fields
  61.      * @var array
  62.      */
  63.     protected $arrOrderFields = array();
  65.     /**
  66.      * Unique fields
  67.      * @var array
  68.      */
  69.     protected $arrUniqueFields = array();
  71.     /**
  72.      * Keys
  73.      * @var array
  74.      */
  75.     protected $arrKeys = array();
  77.     /**
  78.      * Relations
  79.      * @var array
  80.      */
  81.     protected $arrRelations = array();
  83.     /**
  84.      * SQL buffer
  85.      * @var array
  86.      */
  87.     protected static $arrSql = array();
  89.     /**
  90.      * Database table
  91.      * @var boolean
  92.      */
  93.     protected $blnIsDbTable = false;
  95.     /**
  96.      * database.sql file paths
  97.      * @var array|null
  98.      */
  99.     private static $arrDatabaseSqlFiles;
  101.     /**
  102.      * Load or create the extract
  103.      *
  104.      * @param string $strTable The table name
  105.      *
  106.      * @throws \Exception If $strTable is empty
  107.      */
  108.     protected function __construct($strTable)
  109.     {
  110.         if (!$strTable)
  111.         {
  112.             throw new \Exception('The table name must not be empty');
  113.         }
  115.         parent::__construct();
  117.         $this->strTable = $strTable;
  119.         $strFile = System::getContainer()->getParameter('kernel.cache_dir') . '/contao/sql/' . $strTable . '.php';
  121.         // Try to load from cache
  122.         if (file_exists($strFile))
  123.         {
  124.             include $strFile;
  125.         }
  126.         else
  127.         {
  128.             $this->createExtract();
  129.         }
  130.     }
  132.     /**
  133.      * Prevent cloning of the object (Singleton)
  134.      */
  135.     final public function __clone()
  136.     {
  137.     }
  139.     /**
  140.      * Get one object instance per table
  141.      *
  142.      * @param string $strTable The table name
  143.      *
  144.      * @return DcaExtractor The object instance
  145.      */
  146.     public static function getInstance($strTable)
  147.     {
  148.         if (!isset(static::$arrInstances[$strTable]))
  149.         {
  150.             static::$arrInstances[$strTable] = new static($strTable);
  151.         }
  153.         return static::$arrInstances[$strTable];
  154.     }
  156.     /**
  157.      * Return the meta data as array
  158.      *
  159.      * @return array The meta data
  160.      */
  161.     public function getMeta()
  162.     {
  163.         return $this->arrMeta;
  164.     }
  166.     /**
  167.      * Return true if there is meta data
  168.      *
  169.      * @return boolean True if there is meta data
  170.      */
  171.     public function hasMeta()
  172.     {
  173.         return !empty($this->arrMeta);
  174.     }
  176.     /**
  177.      * Return the fields as array
  178.      *
  179.      * @return array The fields array
  180.      */
  181.     public function getFields()
  182.     {
  183.         return $this->arrFields;
  184.     }
  186.     /**
  187.      * Return true if there are fields
  188.      *
  189.      * @return boolean True if there are fields
  190.      */
  191.     public function hasFields()
  192.     {
  193.         return !empty($this->arrFields);
  194.     }
  196.     /**
  197.      * Return the order fields as array
  198.      *
  199.      * @return array The order fields array
  200.      */
  201.     public function getOrderFields()
  202.     {
  203.         return $this->arrOrderFields;
  204.     }
  206.     /**
  207.      * Return true if there are order fields
  208.      *
  209.      * @return boolean True if there are order fields
  210.      */
  211.     public function hasOrderFields()
  212.     {
  213.         return !empty($this->arrOrderFields);
  214.     }
  216.     /**
  217.      * Return an array of unique columns
  218.      *
  219.      * @return array
  220.      */
  221.     public function getUniqueFields()
  222.     {
  223.         return $this->arrUniqueFields;
  224.     }
  226.     /**
  227.      * Return true if there are unique fields
  228.      *
  229.      * @return boolean True if there are unique fields
  230.      */
  231.     public function hasUniqueFields()
  232.     {
  233.         return !empty($this->arrUniqueFields);
  234.     }
  236.     /**
  237.      * Return the keys as array
  238.      *
  239.      * @return array The keys array
  240.      */
  241.     public function getKeys()
  242.     {
  243.         return $this->arrKeys;
  244.     }
  246.     /**
  247.      * Return true if there are keys
  248.      *
  249.      * @return boolean True if there are keys
  250.      */
  251.     public function hasKeys()
  252.     {
  253.         return !empty($this->arrKeys);
  254.     }
  256.     /**
  257.      * Return the relations as array
  258.      *
  259.      * @return array The relations array
  260.      */
  261.     public function getRelations()
  262.     {
  263.         return $this->arrRelations;
  264.     }
  266.     /**
  267.      * Return true if there are relations
  268.      *
  269.      * @return boolean True if there are relations
  270.      */
  271.     public function hasRelations()
  272.     {
  273.         return !empty($this->arrRelations);
  274.     }
  276.     /**
  277.      * Return true if the extract relates to a database table
  278.      *
  279.      * @return boolean True if the extract relates to a database table
  280.      */
  281.     public function isDbTable()
  282.     {
  283.         return $this->blnIsDbTable;
  284.     }
  286.     /**
  287.      * Return an array that can be used by the database installer
  288.      *
  289.      * @return array The data array
  290.      */
  291.     public function getDbInstallerArray()
  292.     {
  293.         $return = array();
  295.         // Fields
  296.         foreach ($this->arrFields as $k=>$v)
  297.         {
  298.             if (\is_array($v))
  299.             {
  300.                 if (!isset($v['name']))
  301.                 {
  302.                     $v['name'] = $k;
  303.                 }
  305.                 $return['SCHEMA_FIELDS'][$k] = $v;
  306.             }
  307.             else
  308.             {
  309.                 $return['TABLE_FIELDS'][$k] = '`' . $k . '` ' . $v;
  310.             }
  311.         }
  313.         $quote = static function ($item) { return '`' . $item . '`'; };
  315.         // Keys
  316.         foreach ($this->arrKeys as $k=>$v)
  317.         {
  318.             // Handle multi-column indexes (see #5556)
  319.             if (strpos($k, ',') !== false)
  320.             {
  321.                 $f = array_map($quote, StringUtil::trimsplit(',', $k));
  322.                 $k = str_replace(',', '_', $k);
  323.             }
  324.             else
  325.             {
  326.                 $f = array($quote($k));
  327.             }
  329.             if ($v == 'primary')
  330.             {
  331.                 $k = 'PRIMARY';
  332.                 $v = 'PRIMARY KEY  (' . implode(', ', $f) . ')';
  333.             }
  334.             elseif ($v == 'index')
  335.             {
  336.                 $v = 'KEY `' . $k . '` (' . implode(', ', $f) . ')';
  337.             }
  338.             else
  339.             {
  340.                 $v = strtoupper($v) . ' KEY `' . $k . '` (' . implode(', ', $f) . ')';
  341.             }
  343.             $return['TABLE_CREATE_DEFINITIONS'][$k] = $v;
  344.         }
  346.         $return['TABLE_OPTIONS'] = '';
  348.         // Options
  349.         foreach ($this->arrMeta as $k=>$v)
  350.         {
  351.             if ($k == 'engine')
  352.             {
  353.                 $return['TABLE_OPTIONS'] .= ' ENGINE=' . $v;
  354.             }
  355.             elseif ($k == 'charset')
  356.             {
  357.                 $return['TABLE_OPTIONS'] .= ' DEFAULT CHARSET=' . $v;
  358.             }
  359.             elseif ($k == 'collate')
  360.             {
  361.                 $return['TABLE_OPTIONS'] .= ' COLLATE ' . $v;
  362.             }
  363.         }
  365.         return $return;
  366.     }
  368.     /**
  369.      * Create the extract from the DCA or the database.sql files
  370.      */
  371.     protected function createExtract()
  372.     {
  373.         // Load the default language file (see #7202)
  374.         if (empty($GLOBALS['TL_LANG']['MSC']))
  375.         {
  376.             System::loadLanguageFile('default');
  377.         }
  379.         // Load the data container
  380.         $this->loadDataContainer($this->strTable);
  382.         // Return if the table is not defined
  383.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]))
  384.         {
  385.             return;
  386.         }
  388.         // Return if the DC type is "File"
  389.         if (is_a(DataContainer::getDriverForTable($this->strTable), DC_File::class, true))
  390.         {
  391.             return;
  392.         }
  394.         // Return if the DC type is "Folder" and the DC is not database assisted
  395.         if (is_a(DataContainer::getDriverForTable($this->strTable), DC_Folder::class, true) && empty($GLOBALS['TL_DCA'][$this->strTable]['config']['databaseAssisted']))
  396.         {
  397.             return;
  398.         }
  400.         $blnFromFile = false;
  401.         $arrRelations = array();
  403.         // Check whether there are fields (see #4826)
  404.         if (isset($GLOBALS['TL_DCA'][$this->strTable]['fields']))
  405.         {
  406.             foreach ($GLOBALS['TL_DCA'][$this->strTable]['fields'] as $field=>$config)
  407.             {
  408.                 // Check whether all fields have an SQL definition
  409.                 if (!\array_key_exists('sql', $config) && isset($config['inputType']))
  410.                 {
  411.                     $blnFromFile = true;
  412.                 }
  414.                 // Check whether there is a relation (see #6524)
  415.                 if (isset($config['relation']))
  416.                 {
  417.                     $table = null;
  419.                     if (isset($config['foreignKey']))
  420.                     {
  421.                         $table = explode('.', $config['foreignKey'])[0];
  422.                     }
  424.                     $arrRelations[$field] = array_merge(array('table'=>$table, 'field'=>'id'), $config['relation']);
  426.                     // Store the field delimiter if the related IDs are stored in CSV format (see #257)
  427.                     if (isset($config['eval']['csv']))
  428.                     {
  429.                         $arrRelations[$field]['delimiter'] = $config['eval']['csv'];
  430.                     }
  432.                     // Table name and field name are mandatory
  433.                     if (empty($arrRelations[$field]['table']) || empty($arrRelations[$field]['field']))
  434.                     {
  435.                         throw new \Exception('Incomplete relation defined for ' . $this->strTable . '.' . $field);
  436.                     }
  437.                 }
  438.             }
  439.         }
  441.         $sql = $GLOBALS['TL_DCA'][$this->strTable]['config']['sql'] ?? array();
  442.         $fields = $GLOBALS['TL_DCA'][$this->strTable]['fields'] ?? array();
  444.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  445.         if ($blnFromFile && !empty($files = $this->getDatabaseSqlFiles()))
  446.         {
  447.             @trigger_error('Using database.sql files has been deprecated and will no longer work in Contao 5.0. Use a DCA file instead.', E_USER_DEPRECATED);
  449.             if (!isset(static::$arrSql[$this->strTable]))
  450.             {
  451.                 $arrSql = array();
  453.                 foreach ($files as $file)
  454.                 {
  455.                     $arrSql = array_merge_recursive($arrSql, SqlFileParser::parse($file));
  456.                 }
  458.                 static::$arrSql = $arrSql;
  459.             }
  461.             $arrTable = static::$arrSql[$this->strTable];
  463.             if (\is_array($arrTable['TABLE_OPTIONS']))
  464.             {
  465.                 $arrTable['TABLE_OPTIONS'] = $arrTable['TABLE_OPTIONS'][0]; // see #324
  466.             }
  468.             list($engine, , $charset) = explode(' ', trim($arrTable['TABLE_OPTIONS']));
  470.             if ($engine)
  471.             {
  472.                 $sql['engine'] = str_replace('ENGINE=', '', $engine);
  473.             }
  475.             if ($charset)
  476.             {
  477.                 $sql['charset'] = str_replace('CHARSET=', '', $charset);
  478.             }
  480.             // Fields
  481.             if (isset($arrTable['TABLE_FIELDS']))
  482.             {
  483.                 foreach ($arrTable['TABLE_FIELDS'] as $k=>$v)
  484.                 {
  485.                     $fields[$k]['sql'] = str_replace('`' . $k . '` ', '', $v);
  486.                 }
  487.             }
  489.             // Keys
  490.             if (isset($arrTable['TABLE_CREATE_DEFINITIONS']))
  491.             {
  492.                 foreach ($arrTable['TABLE_CREATE_DEFINITIONS'] as $strKey)
  493.                 {
  494.                     if (preg_match('/^([A-Z]+ )?KEY .+\(([^)]+)\)$/', $strKey, $arrMatches) && preg_match_all('/`([^`]+)`/', $arrMatches[2], $arrFields))
  495.                     {
  496.                         $type = trim($arrMatches[1]);
  497.                         $field = implode(',', $arrFields[1]);
  498.                         $sql['keys'][$field] = $type ? strtolower($type) : 'index';
  499.                     }
  500.                 }
  501.             }
  502.         }
  504.         // Relations
  505.         if (!empty($arrRelations))
  506.         {
  507.             $this->arrRelations = array();
  509.             foreach ($arrRelations as $field=>$config)
  510.             {
  511.                 $this->arrRelations[$field] = array();
  513.                 foreach ($config as $k=>$v)
  514.                 {
  515.                     $this->arrRelations[$field][$k] = $v;
  516.                 }
  517.             }
  518.         }
  520.         // Not a database table or no field information
  521.         if (empty($sql) || empty($fields))
  522.         {
  523.             return;
  524.         }
  526.         $params = System::getContainer()->get('database_connection')->getParams();
  528.         // Add the default engine and charset if none is given
  529.         if (empty($sql['engine']))
  530.         {
  531.             $sql['engine'] = $params['defaultTableOptions']['engine'] ?? 'InnoDB';
  532.         }
  534.         if (empty($sql['charset']))
  535.         {
  536.             $sql['charset'] = $params['defaultTableOptions']['charset'] ?? 'utf8mb4';
  537.         }
  539.         if (empty($sql['collate']))
  540.         {
  541.             $sql['collate'] = $params['defaultTableOptions']['collate'] ?? 'utf8mb4_unicode_ci';
  542.         }
  544.         // Meta
  545.         $this->arrMeta = array
  546.         (
  547.             'engine' => $sql['engine'],
  548.             'charset' => $sql['charset'],
  549.             'collate' => $sql['collate']
  550.         );
  552.         // Fields
  553.         $this->arrFields = array();
  554.         $this->arrOrderFields = array();
  556.         foreach ($fields as $field=>$config)
  557.         {
  558.             if (isset($config['sql']))
  559.             {
  560.                 $this->arrFields[$field] = $config['sql'];
  561.             }
  563.             // Only add order fields of binary fields (see #7785)
  564.             if (isset($config['inputType'], $config['eval']['orderField']) && $config['inputType'] == 'fileTree')
  565.             {
  566.                 $this->arrOrderFields[] = $config['eval']['orderField'];
  567.             }
  569.             if (isset($config['eval']['unique']) && $config['eval']['unique'])
  570.             {
  571.                 $this->arrUniqueFields[] = $field;
  572.             }
  573.         }
  575.         // Keys
  576.         if (!empty($sql['keys']) && \is_array($sql['keys']))
  577.         {
  578.             $this->arrKeys = array();
  580.             foreach ($sql['keys'] as $field=>$type)
  581.             {
  582.                 $this->arrKeys[$field] = $type;
  584.                 if ($type == 'unique')
  585.                 {
  586.                     $this->arrUniqueFields[] = $field;
  587.                 }
  588.             }
  589.         }
  591.         $this->arrUniqueFields = array_unique($this->arrUniqueFields);
  592.         $this->blnIsDbTable = true;
  593.     }
  595.     private function getDatabaseSqlFiles(): array
  596.     {
  597.         if (null !== self::$arrDatabaseSqlFiles)
  598.         {
  599.             return self::$arrDatabaseSqlFiles;
  600.         }
  602.         try
  603.         {
  604.             $files = System::getContainer()->get('contao.resource_locator')->locate('config/database.sql', null, false);
  605.         }
  606.         catch (FileLocatorFileNotFoundException $e)
  607.         {
  608.             $files = array();
  609.         }
  611.         return self::$arrDatabaseSqlFiles = $files;
  612.     }
  613. }
  615. class_alias(DcaExtractor::class, 'DcaExtractor');