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

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. /**
  14.  * Extracts DCA information and cache it
  15.  *
  16.  * The class parses the DCA files and stores various extracts like relations
  17.  * in the cache directory. This meta data can then be loaded and used in the
  18.  * application (e.g. the Model classes).
  19.  *
  20.  * Usage:
  21.  *
  22.  *     $user = DcaExtractor::getInstance('tl_user');
  23.  *
  24.  *     if ($user->hasRelations())
  25.  *     {
  26.  *         print_r($user->getRelations());
  27.  *     }
  28.  *
  29.  * @author Leo Feyer <https://github.com/leofeyer>
  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.      * Meta data
  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.      * Load or create the extract
  95.      *
  96.      * @param string $strTable The table name
  97.      *
  98.      * @throws \Exception If $strTable is empty
  99.      */
  100.     protected function __construct($strTable)
  101.     {
  102.         if (!$strTable)
  103.         {
  104.             throw new \Exception('The table name must not be empty');
  105.         }
  107.         parent::__construct();
  109.         $this->strTable = $strTable;
  111.         $strFile = System::getContainer()->getParameter('kernel.cache_dir') . '/contao/sql/' . $strTable . '.php';
  113.         // Try to load from cache
  114.         if (file_exists($strFile))
  115.         {
  116.             include $strFile;
  117.         }
  118.         else
  119.         {
  120.             $this->createExtract();
  121.         }
  122.     }
  124.     /**
  125.      * Prevent cloning of the object (Singleton)
  126.      */
  127.     final public function __clone()
  128.     {
  129.     }
  131.     /**
  132.      * Get one object instance per table
  133.      *
  134.      * @param string $strTable The table name
  135.      *
  136.      * @return DcaExtractor The object instance
  137.      */
  138.     public static function getInstance($strTable)
  139.     {
  140.         if (!isset(static::$arrInstances[$strTable]))
  141.         {
  142.             static::$arrInstances[$strTable] = new static($strTable);
  143.         }
  145.         return static::$arrInstances[$strTable];
  146.     }
  148.     /**
  149.      * Return the meta data as array
  150.      *
  151.      * @return array The meta data
  152.      */
  153.     public function getMeta()
  154.     {
  155.         return $this->arrMeta;
  156.     }
  158.     /**
  159.      * Return true if there is meta data
  160.      *
  161.      * @return boolean True if there is meta data
  162.      */
  163.     public function hasMeta()
  164.     {
  165.         return !empty($this->arrMeta);
  166.     }
  168.     /**
  169.      * Return the fields as array
  170.      *
  171.      * @return array The fields array
  172.      */
  173.     public function getFields()
  174.     {
  175.         return $this->arrFields;
  176.     }
  178.     /**
  179.      * Return true if there are fields
  180.      *
  181.      * @return boolean True if there are fields
  182.      */
  183.     public function hasFields()
  184.     {
  185.         return !empty($this->arrFields);
  186.     }
  188.     /**
  189.      * Return the order fields as array
  190.      *
  191.      * @return array The order fields array
  192.      */
  193.     public function getOrderFields()
  194.     {
  195.         return $this->arrOrderFields;
  196.     }
  198.     /**
  199.      * Return true if there are order fields
  200.      *
  201.      * @return boolean True if there are order fields
  202.      */
  203.     public function hasOrderFields()
  204.     {
  205.         return !empty($this->arrOrderFields);
  206.     }
  208.     /**
  209.      * Return an array of unique columns
  210.      *
  211.      * @return array
  212.      */
  213.     public function getUniqueFields()
  214.     {
  215.         return $this->arrUniqueFields;
  216.     }
  218.     /**
  219.      * Return true if there are unique fields
  220.      *
  221.      * @return boolean True if there are unique fields
  222.      */
  223.     public function hasUniqueFields()
  224.     {
  225.         return !empty($this->arrUniqueFields);
  226.     }
  228.     /**
  229.      * Return the keys as array
  230.      *
  231.      * @return array The keys array
  232.      */
  233.     public function getKeys()
  234.     {
  235.         return $this->arrKeys;
  236.     }
  238.     /**
  239.      * Return true if there are keys
  240.      *
  241.      * @return boolean True if there are keys
  242.      */
  243.     public function hasKeys()
  244.     {
  245.         return !empty($this->arrKeys);
  246.     }
  248.     /**
  249.      * Return the relations as array
  250.      *
  251.      * @return array The relations array
  252.      */
  253.     public function getRelations()
  254.     {
  255.         return $this->arrRelations;
  256.     }
  258.     /**
  259.      * Return true if there are relations
  260.      *
  261.      * @return boolean True if there are relations
  262.      */
  263.     public function hasRelations()
  264.     {
  265.         return !empty($this->arrRelations);
  266.     }
  268.     /**
  269.      * Return true if the extract relates to a database table
  270.      *
  271.      * @return boolean True if the extract relates to a database table
  272.      */
  273.     public function isDbTable()
  274.     {
  275.         return $this->blnIsDbTable;
  276.     }
  278.     /**
  279.      * Return an array that can be used by the database installer
  280.      *
  281.      * @return array The data array
  282.      */
  283.     public function getDbInstallerArray()
  284.     {
  285.         $return = array();
  287.         // Fields
  288.         foreach ($this->arrFields as $k=>$v)
  289.         {
  290.             if (\is_array($v))
  291.             {
  292.                 if (!isset($v['name']))
  293.                 {
  294.                     $v['name'] = $k;
  295.                 }
  297.                 $return['SCHEMA_FIELDS'][$k] = $v;
  298.             }
  299.             else
  300.             {
  301.                 $return['TABLE_FIELDS'][$k] = '`' . $k . '` ' . $v;
  302.             }
  303.         }
  305.         $quote = static function ($item) { return '`' . $item . '`'; };
  307.         // Keys
  308.         foreach ($this->arrKeys as $k=>$v)
  309.         {
  310.             // Handle multi-column indexes (see #5556)
  311.             if (strpos($k, ',') !== false)
  312.             {
  313.                 $f = array_map($quote, StringUtil::trimsplit(',', $k));
  314.                 $k = str_replace(',', '_', $k);
  315.             }
  316.             else
  317.             {
  318.                 $f = array($quote($k));
  319.             }
  321.             if ($v == 'primary')
  322.             {
  323.                 $k = 'PRIMARY';
  324.                 $v = 'PRIMARY KEY  (' . implode(', ', $f) . ')';
  325.             }
  326.             elseif ($v == 'index')
  327.             {
  328.                 $v = 'KEY `' . $k . '` (' . implode(', ', $f) . ')';
  329.             }
  330.             else
  331.             {
  332.                 $v = strtoupper($v) . ' KEY `' . $k . '` (' . implode(', ', $f) . ')';
  333.             }
  335.             $return['TABLE_CREATE_DEFINITIONS'][$k] = $v;
  336.         }
  338.         $return['TABLE_OPTIONS'] = '';
  340.         // Options
  341.         foreach ($this->arrMeta as $k=>$v)
  342.         {
  343.             if ($k == 'engine')
  344.             {
  345.                 $return['TABLE_OPTIONS'] .= ' ENGINE=' . $v;
  346.             }
  347.             elseif ($k == 'charset')
  348.             {
  349.                 $return['TABLE_OPTIONS'] .= ' DEFAULT CHARSET=' . $v;
  350.             }
  351.             elseif ($k == 'collate')
  352.             {
  353.                 $return['TABLE_OPTIONS'] .= ' COLLATE ' . $v;
  354.             }
  355.         }
  357.         return $return;
  358.     }
  360.     /**
  361.      * Create the extract from the DCA or the database.sql files
  362.      */
  363.     protected function createExtract()
  364.     {
  365.         // Load the default language file (see #7202)
  366.         if (empty($GLOBALS['TL_LANG']['MSC']))
  367.         {
  368.             System::loadLanguageFile('default');
  369.         }
  371.         // Load the data container
  372.         $this->loadDataContainer($this->strTable);
  374.         // Return if the table is not defined
  375.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]))
  376.         {
  377.             return;
  378.         }
  380.         // Return if the DC type is "File"
  381.         if ($GLOBALS['TL_DCA'][$this->strTable]['config']['dataContainer'] == 'File')
  382.         {
  383.             return;
  384.         }
  386.         // Return if the DC type is "Folder" and the DC is not database assisted
  387.         if ($GLOBALS['TL_DCA'][$this->strTable]['config']['dataContainer'] == 'Folder' && empty($GLOBALS['TL_DCA'][$this->strTable]['config']['databaseAssisted']))
  388.         {
  389.             return;
  390.         }
  392.         $blnFromFile = false;
  393.         $arrRelations = array();
  395.         // Check whether there are fields (see #4826)
  396.         if (isset($GLOBALS['TL_DCA'][$this->strTable]['fields']))
  397.         {
  398.             foreach ($GLOBALS['TL_DCA'][$this->strTable]['fields'] as $field=>$config)
  399.             {
  400.                 // Check whether all fields have an SQL definition
  401.                 if (!\array_key_exists('sql', $config) && isset($config['inputType']))
  402.                 {
  403.                     $blnFromFile = true;
  404.                 }
  406.                 // Check whether there is a relation (see #6524)
  407.                 if (isset($config['relation']))
  408.                 {
  409.                     $table = null;
  411.                     if (isset($config['foreignKey']))
  412.                     {
  413.                         $table = substr($config['foreignKey'], 0, strrpos($config['foreignKey'], '.'));
  414.                     }
  416.                     $arrRelations[$field] = array_merge(array('table'=>$table, 'field'=>'id'), $config['relation']);
  418.                     // Store the field delimiter if the related IDs are stored in CSV format (see #257)
  419.                     if (isset($config['eval']['csv']))
  420.                     {
  421.                         $arrRelations[$field]['delimiter'] = $config['eval']['csv'];
  422.                     }
  424.                     // Table name and field name are mandatory
  425.                     if (empty($arrRelations[$field]['table']) || empty($arrRelations[$field]['field']))
  426.                     {
  427.                         throw new \Exception('Incomplete relation defined for ' . $this->strTable . '.' . $field);
  428.                     }
  429.                 }
  430.             }
  431.         }
  433.         $sql = $GLOBALS['TL_DCA'][$this->strTable]['config']['sql'] ?? array();
  434.         $fields = $GLOBALS['TL_DCA'][$this->strTable]['fields'] ?? array();
  436.         // Deprecated since Contao 4.0, to be removed in Contao 5.0
  437.         if ($blnFromFile)
  438.         {
  439.             @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);
  441.             if (!isset(static::$arrSql[$this->strTable]))
  442.             {
  443.                 $arrSql = array();
  445.                 try
  446.                 {
  447.                     $files = System::getContainer()->get('contao.resource_locator')->locate('config/database.sql', null, false);
  448.                 }
  449.                 catch (\InvalidArgumentException $e)
  450.                 {
  451.                     $files = array();
  452.                 }
  454.                 foreach ($files as $file)
  455.                 {
  456.                     $arrSql = array_merge_recursive($arrSql, SqlFileParser::parse($file));
  457.                 }
  459.                 static::$arrSql = $arrSql;
  460.             }
  462.             $arrTable = static::$arrSql[$this->strTable];
  464.             if (\is_array($arrTable['TABLE_OPTIONS']))
  465.             {
  466.                 $arrTable['TABLE_OPTIONS'] = $arrTable['TABLE_OPTIONS'][0]; // see #324
  467.             }
  469.             list($engine, , $charset) = explode(' ', trim($arrTable['TABLE_OPTIONS']));
  471.             if ($engine)
  472.             {
  473.                 $sql['engine'] = str_replace('ENGINE=', '', $engine);
  474.             }
  476.             if ($charset)
  477.             {
  478.                 $sql['charset'] = str_replace('CHARSET=', '', $charset);
  479.             }
  481.             // Fields
  482.             if (isset($arrTable['TABLE_FIELDS']))
  483.             {
  484.                 foreach ($arrTable['TABLE_FIELDS'] as $k=>$v)
  485.                 {
  486.                     $fields[$k]['sql'] = str_replace('`' . $k . '` ', '', $v);
  487.                 }
  488.             }
  490.             // Keys
  491.             if (isset($arrTable['TABLE_CREATE_DEFINITIONS']))
  492.             {
  493.                 foreach ($arrTable['TABLE_CREATE_DEFINITIONS'] as $strKey)
  494.                 {
  495.                     if (preg_match('/^([A-Z]+ )?KEY .+\(([^)]+)\)$/', $strKey, $arrMatches) && preg_match_all('/`([^`]+)`/', $arrMatches[2], $arrFields))
  496.                     {
  497.                         $type = trim($arrMatches[1]);
  498.                         $field = implode(',', $arrFields[1]);
  499.                         $sql['keys'][$field] = $type ? strtolower($type) : 'index';
  500.                     }
  501.                 }
  502.             }
  503.         }
  505.         // Relations
  506.         if (!empty($arrRelations))
  507.         {
  508.             $this->arrRelations = array();
  510.             foreach ($arrRelations as $field=>$config)
  511.             {
  512.                 $this->arrRelations[$field] = array();
  514.                 foreach ($config as $k=>$v)
  515.                 {
  516.                     $this->arrRelations[$field][$k] = $v;
  517.                 }
  518.             }
  519.         }
  521.         // Not a database table or no field information
  522.         if (empty($sql) || empty($fields))
  523.         {
  524.             return;
  525.         }
  527.         $params = System::getContainer()->get('database_connection')->getParams();
  529.         // Add the default engine and charset if none is given
  530.         if (empty($sql['engine']))
  531.         {
  532.             $sql['engine'] = $params['defaultTableOptions']['engine'] ?? 'InnoDB';
  533.         }
  535.         if (empty($sql['charset']))
  536.         {
  537.             $sql['charset'] = $params['defaultTableOptions']['charset'] ?? 'utf8mb4';
  538.         }
  540.         if (empty($sql['collate']))
  541.         {
  542.             $sql['collate'] = $params['defaultTableOptions']['collate'] ?? 'utf8mb4_unicode_ci';
  543.         }
  545.         // Meta
  546.         $this->arrMeta = array
  547.         (
  548.             'engine' => $sql['engine'],
  549.             'charset' => $sql['charset'],
  550.             'collate' => $sql['collate']
  551.         );
  553.         // Fields
  554.         $this->arrFields = array();
  555.         $this->arrOrderFields = array();
  557.         foreach ($fields as $field=>$config)
  558.         {
  559.             if (isset($config['sql']))
  560.             {
  561.                 $this->arrFields[$field] = $config['sql'];
  562.             }
  564.             // Only add order fields of binary fields (see #7785)
  565.             if (isset($config['inputType'], $config['eval']['orderField']) && $config['inputType'] == 'fileTree')
  566.             {
  567.                 $this->arrOrderFields[] = $config['eval']['orderField'];
  568.             }
  570.             if (isset($config['eval']['unique']) && $config['eval']['unique'])
  571.             {
  572.                 $this->arrUniqueFields[] = $field;
  573.             }
  574.         }
  576.         // Keys
  577.         if (!empty($sql['keys']) && \is_array($sql['keys']))
  578.         {
  579.             $this->arrKeys = array();
  581.             foreach ($sql['keys'] as $field=>$type)
  582.             {
  583.                 $this->arrKeys[$field] = $type;
  585.                 if ($type == 'unique')
  586.                 {
  587.                     $this->arrUniqueFields[] = $field;
  588.                 }
  589.             }
  590.         }
  592.         $this->arrUniqueFields = array_unique($this->arrUniqueFields);
  593.         $this->blnIsDbTable = true;
  594.     }
  595. }
  597. class_alias(DcaExtractor::class, 'DcaExtractor');