4 * Read the schema specification and parse into internal data structures
6 class CRM_Core_CodeGen_Specification
{
10 protected $classNames;
16 * @param string $buildVersion
17 * Which version of the schema to build.
18 * @param bool $verbose
20 public function parse($schemaPath, $buildVersion, $verbose = TRUE) {
21 $this->buildVersion
= $buildVersion;
24 echo "Parsing schema description " . $schemaPath . "\n";
26 $dbXML = CRM_Core_CodeGen_Util_Xml
::parse($schemaPath);
29 echo "Extracting database information\n";
31 $this->database
= &$this->getDatabase($dbXML);
33 $this->classNames
= [];
35 // TODO: peel DAO-specific stuff out of getTables, and spec reading into its own class
37 echo "Extracting table information\n";
39 $this->tables
= $this->getTables($dbXML, $this->database
);
41 $this->resolveForeignKeys($this->tables
, $this->classNames
);
42 $this->tables
= $this->orderTables($this->tables
);
44 // add archive tables here
45 foreach ($this->tables
as $name => $table) {
46 if ($table['archive'] == 'true') {
47 $name = 'archive_' . $table['name'];
48 $table['name'] = $name;
49 $table['archive'] = 'false';
50 if (isset($table['foreignKey'])) {
51 foreach ($table['foreignKey'] as $fkName => $fkValue) {
52 if ($this->tables
[$fkValue['table']]['archive'] == 'true') {
53 $table['foreignKey'][$fkName]['table'] = 'archive_' . $table['foreignKey'][$fkName]['table'];
54 $table['foreignKey'][$fkName]['uniqName']
55 = str_replace('FK_', 'FK_archive_', $table['foreignKey'][$fkName]['uniqName']);
58 $archiveTables[$name] = $table;
69 public function &getDatabase(&$dbXML) {
70 $database = ['name' => trim((string ) $dbXML->name
)];
73 $this->checkAndAppend($attributes, $dbXML, 'character_set', 'DEFAULT CHARACTER SET ', '');
74 $this->checkAndAppend($attributes, $dbXML, 'collate', 'COLLATE ', '');
75 $attributes .= ' ROW_FORMAT=DYNAMIC';
76 $database['attributes'] = $attributes;
78 $tableAttributes_modern = $tableAttributes_simple = '';
79 $this->checkAndAppend($tableAttributes_modern, $dbXML, 'table_type', 'ENGINE=', '');
80 $this->checkAndAppend($tableAttributes_simple, $dbXML, 'table_type', 'TYPE=', '');
81 $database['tableAttributes_modern'] = trim($tableAttributes_modern . ' ' . $attributes);
82 $database['tableAttributes_simple'] = trim($tableAttributes_simple);
84 $database['comment'] = $this->value('comment', $dbXML, '');
95 public function getTables($dbXML, &$database) {
97 foreach ($dbXML->tables
as $tablesXML) {
98 foreach ($tablesXML->table
as $tableXML) {
99 if ($this->value('drop', $tableXML, 0) > 0 && version_compare($this->value('drop', $tableXML, 0), $this->buildVersion
, '<=')) {
103 if (version_compare($this->value('add', $tableXML, 0), $this->buildVersion
, '<=')) {
104 $this->getTable($tableXML, $database, $tables);
113 * @param array $tables
114 * @param string[] $classNames
116 public function resolveForeignKeys(&$tables, &$classNames) {
117 foreach (array_keys($tables) as $name) {
118 $this->resolveForeignKey($tables, $classNames, $name);
123 * @param array $tables
124 * @param string[] $classNames
125 * @param string $name
127 public function resolveForeignKey(&$tables, &$classNames, $name) {
128 if (!array_key_exists('foreignKey', $tables[$name])) {
132 foreach (array_keys($tables[$name]['foreignKey']) as $fkey) {
133 $ftable = $tables[$name]['foreignKey'][$fkey]['table'];
134 if (!array_key_exists($ftable, $classNames)) {
135 echo "$ftable is not a valid foreign key table in $name\n";
138 $tables[$name]['foreignKey'][$fkey]['className'] = $classNames[$ftable];
139 $tables[$name]['foreignKey'][$fkey]['fileName'] = str_replace('_', '/', $classNames[$ftable]) . '.php';
140 $tables[$name]['fields'][$fkey]['FKClassName'] = $classNames[$ftable];
145 * @param array $tables
149 public function orderTables(&$tables) {
152 while (!empty($tables)) {
153 foreach (array_keys($tables) as $name) {
154 if ($this->validTable($tables, $ordered, $name)) {
155 $ordered[$name] = $tables[$name];
156 unset($tables[$name]);
164 * @param array $tables
166 * @param string $name
170 public function validTable(&$tables, &$valid, $name) {
171 if (!array_key_exists('foreignKey', $tables[$name])) {
175 foreach (array_keys($tables[$name]['foreignKey']) as $fkey) {
176 $ftable = $tables[$name]['foreignKey'][$fkey]['table'];
177 if (!array_key_exists($ftable, $valid) && $ftable !== $name) {
189 public function getTable($tableXML, &$database, &$tables) {
190 $name = trim((string ) $tableXML->name
);
191 $klass = trim((string ) $tableXML->class);
192 $base = $this->value('base', $tableXML);
193 $sourceFile = "xml/schema/{$base}/{$klass}.xml";
194 $daoPath = "{$base}/DAO/";
195 $baoPath = __DIR__
. '/../../../' . str_replace(' ', '', "{$base}/BAO/");
196 $useBao = $this->value('useBao', $tableXML, file_exists($baoPath . $klass . '.php'));
197 $pre = str_replace('/', '_', $daoPath);
198 $this->classNames
[$name] = $pre . $klass;
200 $localizable = FALSE;
201 foreach ($tableXML->field
as $fieldXML) {
202 if ($fieldXML->localizable
) {
208 $titleFromClass = preg_replace('/([a-z])([A-Z])/', '$1 $2', $klass);
212 'sourceFile' => $sourceFile,
213 'fileName' => $klass . '.php',
214 'objectName' => $klass,
215 'title' => $tableXML->title ??
$titleFromClass,
216 'titlePlural' => $tableXML->titlePlural ?? CRM_Utils_String
::pluralize($tableXML->title ??
$titleFromClass),
217 'icon' => $tableXML->icon ??
NULL,
218 'labelField' => $tableXML->labelField ??
NULL,
219 'add' => $tableXML->add ??
NULL,
220 'component' => $tableXML->component ??
NULL,
221 'paths' => (array) ($tableXML->paths ??
[]),
222 'labelName' => substr($name, 8),
223 'className' => $this->classNames
[$name],
224 'bao' => ($useBao ?
str_replace('DAO', 'BAO', $this->classNames
[$name]) : $this->classNames
[$name]),
225 'entity' => $tableXML->entity ??
$klass,
226 'attributes_simple' => trim($database['tableAttributes_simple']),
227 'attributes_modern' => trim($database['tableAttributes_modern']),
228 'comment' => $this->value('comment', $tableXML),
229 'description' => $this->value('description', $tableXML),
230 'localizable' => $localizable,
231 'log' => $this->value('log', $tableXML, 'false'),
232 'archive' => $this->value('archive', $tableXML, 'false'),
236 foreach ($tableXML->field
as $fieldXML) {
237 if ($this->value('drop', $fieldXML, 0) > 0 && version_compare($this->value('drop', $fieldXML, 0), $this->buildVersion
, '<=')) {
241 if (version_compare($this->value('add', $fieldXML, 0), $this->buildVersion
, '<=')) {
242 $this->getField($fieldXML, $fields);
246 $table['fields'] = &$fields;
248 if ($this->value('primaryKey', $tableXML)) {
249 $this->getPrimaryKey($tableXML->primaryKey
, $fields, $table);
252 if ($this->value('index', $tableXML)) {
254 foreach ($tableXML->index
as $indexXML) {
255 if ($this->value('drop', $indexXML, 0) > 0 && version_compare($this->value('drop', $indexXML, 0), $this->buildVersion
, '<=')) {
259 $this->getIndex($indexXML, $fields, $index);
261 CRM_Core_BAO_SchemaHandler
::addIndexSignature($name, $index);
262 $table['index'] = &$index;
265 if ($this->value('foreignKey', $tableXML)) {
267 foreach ($tableXML->foreignKey
as $foreignXML) {
269 if ($this->value('drop', $foreignXML, 0) > 0 && version_compare($this->value('drop', $foreignXML, 0), $this->buildVersion
, '<=')) {
272 if (version_compare($this->value('add', $foreignXML, 0), $this->buildVersion
, '<=')) {
273 $this->getForeignKey($foreignXML, $fields, $foreign, $name);
276 if (!empty($foreign)) {
277 $table['foreignKey'] = &$foreign;
281 if ($this->value('dynamicForeignKey', $tableXML)) {
282 $dynamicForeign = [];
283 foreach ($tableXML->dynamicForeignKey
as $foreignXML) {
284 if ($this->value('drop', $foreignXML, 0) > 0 && version_compare($this->value('drop', $foreignXML, 0), $this->buildVersion
, '<=')) {
287 if (version_compare($this->value('add', $foreignXML, 0), $this->buildVersion
, '<=')) {
288 $this->getDynamicForeignKey($foreignXML, $dynamicForeign, $name);
291 if (!empty($dynamicForeign)) {
292 $table['dynamicForeignKey'] = $dynamicForeign;
296 $tables[$name] = &$table;
303 public function getField(&$fieldXML, &$fields) {
304 $name = trim((string ) $fieldXML->name
);
305 $field = ['name' => $name, 'localizable' => ((bool) $fieldXML->localizable
) ?
1 : 0];
306 $type = (string) $fieldXML->type
;
310 $field['length'] = (int) $fieldXML->length
;
311 $field['sqlType'] = "$type({$field['length']})";
312 $field['crmType'] = 'CRM_Utils_Type::T_STRING';
313 $field['size'] = $this->getSize($fieldXML);
317 $field['sqlType'] = $type;
318 $field['crmType'] = 'CRM_Utils_Type::T_' . strtoupper($type);
319 // CRM-13497 see fixme below
320 $field['rows'] = isset($fieldXML->html
) ?
$this->value('rows', $fieldXML->html
) : NULL;
321 $field['cols'] = isset($fieldXML->html
) ?
$this->value('cols', $fieldXML->html
) : NULL;
325 $field['sqlType'] = $type;
326 $field['crmType'] = 'CRM_Utils_Type::T_DATE + CRM_Utils_Type::T_TIME';
330 // need this case since some versions of mysql do not have boolean as a valid column type and hence it
331 // is changed to tinyint. hopefully after 2 yrs this case can be removed.
332 $field['sqlType'] = 'tinyint';
333 $field['crmType'] = 'CRM_Utils_Type::T_' . strtoupper($type);
337 $length = $fieldXML->length ?
$fieldXML->length
: '20,2';
338 $field['sqlType'] = 'decimal(' . $length . ')';
339 $field['crmType'] = 'CRM_Utils_Type::T_MONEY';
340 $field['precision'] = $length . ',';
344 $field['sqlType'] = 'double';
345 $field['crmType'] = 'CRM_Utils_Type::T_FLOAT';
349 $field['sqlType'] = $type;
350 if ($type == 'int unsigned' ||
$type == 'tinyint') {
351 $field['crmType'] = 'CRM_Utils_Type::T_INT';
354 $field['crmType'] = $this->value('crmType', $fieldXML, 'CRM_Utils_Type::T_' . strtoupper($type));
359 $field['phpType'] = $this->getPhpType($fieldXML);
360 $field['phpNullable'] = $this->getPhpNullable($fieldXML);
362 $field['required'] = $this->value('required', $fieldXML);
363 $field['collate'] = $this->value('collate', $fieldXML);
364 $field['comment'] = $this->value('comment', $fieldXML);
365 $field['default'] = $this->value('default', $fieldXML);
366 $field['import'] = $this->value('import', $fieldXML);
367 if ($this->value('export', $fieldXML)) {
368 $field['export'] = $this->value('export', $fieldXML);
371 $field['export'] = $this->value('import', $fieldXML);
373 $field['rule'] = $this->value('rule', $fieldXML);
374 $field['title'] = $this->value('title', $fieldXML);
375 if (!$field['title']) {
376 $field['title'] = $this->composeTitle($name);
378 $field['headerPattern'] = $this->value('headerPattern', $fieldXML);
379 $field['dataPattern'] = $this->value('dataPattern', $fieldXML);
380 $field['readonly'] = $this->value('readonly', $fieldXML);
381 $field['uniqueName'] = $this->value('uniqueName', $fieldXML);
382 $field['uniqueTitle'] = $this->value('uniqueTitle', $fieldXML);
383 $field['serialize'] = $this->value('serialize', $fieldXML);
384 $field['component'] = $this->value('component', $fieldXML);
385 $field['html'] = $this->value('html', $fieldXML);
386 $field['contactType'] = $this->value('contactType', $fieldXML);
387 if (isset($fieldXML->permission
)) {
388 $field['permission'] = trim($this->value('permission', $fieldXML));
389 $field['permission'] = $field['permission'] ?
array_filter(array_map('trim', explode(',', $field['permission']))) : [];
390 if (isset($fieldXML->permission
->or)) {
391 $field['permission'][] = array_filter(array_map('trim', explode(',', $fieldXML->permission
->or)));
394 if (!empty($field['html'])) {
400 /* Fixme: prior to CRM-13497 these were in a flat structure
401 // CRM-13497 moved them to be nested within 'html' but there's no point
402 // making that change in the DAOs right now since we are in the process of
403 // moving to docrtine anyway.
404 // So translating from nested xml back to flat structure for now.
410 foreach ($validOptions as $htmlOption) {
411 if (!empty($fieldXML->html
->$htmlOption)) {
412 $field['html'][$htmlOption] = $this->value($htmlOption, $fieldXML->html
);
417 // in multilingual context popup, we need extra information to create appropriate widget
418 if ($fieldXML->localizable
) {
419 if (isset($fieldXML->html
)) {
420 $field['widget'] = (array) $fieldXML->html
;
424 $field['widget'] = ['type' => 'Text'];
426 if (isset($fieldXML->required
)) {
427 $field['widget']['required'] = $this->value('required', $fieldXML);
430 if (isset($fieldXML->localize_context
)) {
431 $field['localize_context'] = $fieldXML->localize_context
;
433 $field['add'] = $this->value('add', $fieldXML);
434 $field['pseudoconstant'] = $this->value('pseudoconstant', $fieldXML);
435 if (!empty($field['pseudoconstant'])) {
436 //ok this is a bit long-winded but it gets there & is consistent with above approach
437 $field['pseudoconstant'] = [];
439 // Fields can specify EITHER optionGroupName OR table, not both
440 // (since declaring optionGroupName means we are using the civicrm_option_value table)
443 // If table is specified, keyColumn and labelColumn are also required
446 // Non-translated machine name for programmatic lookup. Defaults to 'name' if that column exists
448 // Column to fetch in "abbreviate" context
450 // Where clause snippet (will be joined to the rest of the query with AND operator)
452 // callback function incase of static arrays
454 // Path to options edit form
456 // Should options for this field be prefetched (for presenting on forms).
457 // The default is TRUE, but adding FALSE helps when there could be many options
460 foreach ($validOptions as $pseudoOption) {
461 if (!empty($fieldXML->pseudoconstant
->$pseudoOption)) {
462 $field['pseudoconstant'][$pseudoOption] = $this->value($pseudoOption, $fieldXML->pseudoconstant
);
465 if (!isset($field['pseudoconstant']['optionEditPath']) && !empty($field['pseudoconstant']['optionGroupName'])) {
466 $field['pseudoconstant']['optionEditPath'] = 'civicrm/admin/options/' . $field['pseudoconstant']['optionGroupName'];
468 // For now, fields that have option lists that are not in the db can simply
469 // declare an empty pseudoconstant tag and we'll add this placeholder.
470 // That field's BAO::buildOptions fn will need to be responsible for generating the option list
471 if (empty($field['pseudoconstant'])) {
472 $field['pseudoconstant'] = 'not in database';
475 $fields[$name] = &$field;
479 * Returns the PHPtype used within the DAO object
481 * @param object $fieldXML
484 private function getPhpType($fieldXML) {
485 $type = $fieldXML->type
;
486 $phpType = $this->value('phpType', $fieldXML, 'string');
488 if ($type == 'int' ||
$type == 'int unsigned' ||
$type == 'tinyint') {
492 if ($type == 'float' ||
$type == 'decimal') {
496 if ($type == 'boolean') {
500 if ($phpType !== 'string') {
501 // Values are almost always fetched from the database as string
502 $phpType .= '|string';
509 * Returns whether the field is nullable in PHP.
511 * - The SQL field is nullable
512 * - The field is a primary key, and so is null before new objects are saved
514 * @param object $fieldXML
517 private function getPhpNullable($fieldXML) {
518 $required = $this->value('required', $fieldXML);
527 * @param string $name
531 public function composeTitle($name) {
532 $names = explode('_', strtolower($name));
534 for ($i = 0; $i < count($names); $i++
) {
535 if ($names[$i] === 'id' ||
$names[$i] === 'is') {
536 // id's do not get titles
540 if ($names[$i] === 'im') {
544 $names[$i] = ucfirst(trim($names[$i]));
547 $title = $title . ' ' . $names[$i];
553 * @param object $primaryXML
554 * @param array $fields
555 * @param array $table
557 public function getPrimaryKey(&$primaryXML, &$fields, &$table) {
558 $name = trim((string ) $primaryXML->name
);
560 // set the autoincrement property of the field
561 $auto = $this->value('autoincrement', $primaryXML);
562 if (isset($fields[$name])) {
563 $fields[$name]['autoincrement'] = $auto;
564 $fields[$name]['phpNullable'] = TRUE;
569 'autoincrement' => $auto,
573 foreach ($primaryXML->fieldName
as $v) {
574 $fieldName = (string) ($v);
575 $length = (string) ($v['length']);
576 if (strlen($length) > 0) {
577 $fieldName = "$fieldName($length)";
579 $primaryKey['field'][] = $fieldName;
582 // when field array is empty set it to the name of the primary key.
583 if (empty($primaryKey['field'])) {
584 $primaryKey['field'][] = $name;
587 // all fieldnames have to be defined and should exist in schema.
588 foreach ($primaryKey['field'] as $fieldName) {
590 echo "Invalid field definition for index '$name' in table ${table['name']}\n";
593 $parenOffset = strpos($fieldName, '(');
594 if ($parenOffset > 0) {
595 $fieldName = substr($fieldName, 0, $parenOffset);
597 if (!array_key_exists($fieldName, $fields)) {
598 echo "Missing definition of field '$fieldName' for index '$name' in table ${table['name']}\n";
604 $table['primaryKey'] = &$primaryKey;
612 public function getIndex(&$indexXML, &$fields, &$indices) {
613 //echo "\n\n*******************************************************\n";
614 //echo "entering getIndex\n";
617 // empty index name is fine
618 $indexName = trim((string) $indexXML->name
);
619 $index['name'] = $indexName;
620 $index['field'] = [];
623 foreach ($indexXML->fieldName
as $v) {
624 $fieldName = (string) ($v);
625 $length = (string) ($v['length']);
626 if (strlen($length) > 0) {
627 $fieldName = "$fieldName($length)";
629 $index['field'][] = $fieldName;
632 $index['localizable'] = FALSE;
633 foreach ($index['field'] as $fieldName) {
634 if (isset($fields[$fieldName]) and $fields[$fieldName]['localizable']) {
635 $index['localizable'] = TRUE;
640 // check for unique index
641 if ($this->value('unique', $indexXML)) {
642 $index['unique'] = TRUE;
645 // field array cannot be empty
646 if (empty($index['field'])) {
647 echo "No fields defined for index $indexName\n";
651 // all fieldnames have to be defined and should exist in schema.
652 foreach ($index['field'] as $fieldName) {
654 echo "Invalid field definition for index '$indexName'\n";
657 $parenOffset = strpos($fieldName, '(');
658 if ($parenOffset > 0) {
659 $fieldName = substr($fieldName, 0, $parenOffset);
661 if (!array_key_exists($fieldName, $fields)) {
662 echo "Missing definition of field '$fieldName' for index '$indexName'. Fields defined:\n";
667 $indices[$indexName] = &$index;
673 * @param $foreignKeys
674 * @param string $currentTableName
676 public function getForeignKey(&$foreignXML, &$fields, &$foreignKeys, &$currentTableName) {
677 $name = trim((string ) $foreignXML->name
);
679 /** need to make sure there is a field of type name */
680 if (!array_key_exists($name, $fields)) {
681 echo "Foreign key '$name' in $currentTableName does not have a field definition, ignoring\n";
685 /** need to check for existence of table and key **/
686 $table = trim($this->value('table', $foreignXML));
690 'uniqName' => "FK_{$currentTableName}_{$name}",
691 'key' => trim($this->value('key', $foreignXML)),
692 'import' => $this->value('import', $foreignXML, FALSE),
693 'export' => $this->value('import', $foreignXML, FALSE),
694 // we do this matching in a separate phase (resolveForeignKeys)
696 'onDelete' => $this->value('onDelete', $foreignXML, FALSE),
698 $foreignKeys[$name] = &$foreignKey;
703 * @param $dynamicForeignKeys
705 public function getDynamicForeignKey(&$foreignXML, &$dynamicForeignKeys) {
707 'idColumn' => trim($foreignXML->idColumn
),
708 'typeColumn' => trim($foreignXML->typeColumn
),
709 'key' => trim($this->value('key', $foreignXML)),
711 $dynamicForeignKeys[] = $foreignKey;
717 * @param null $default
719 * @return null|string
721 protected function value($key, &$object, $default = NULL) {
722 if (isset($object->$key)) {
723 return (string ) $object->$key;
731 * @param string $name
735 protected function checkAndAppend(&$attributes, &$object, $name, $pre = NULL, $post = NULL) {
736 if (!isset($object->$name)) {
740 $value = $pre . trim($object->$name) . $post;
741 $this->append($attributes, ' ', trim($value));
749 protected function append(&$str, $delim, $name) {
754 if (is_array($name)) {
755 foreach ($name as $n) {
772 $str .= $delim . $name;
778 * Sets the size property of a textfield.
780 * @param string $fieldXML
782 * @return null|string
784 protected function getSize($fieldXML) {
785 // Extract from <size> tag if supplied
786 if (!empty($fieldXML->html
) && $this->value('size', $fieldXML->html
)) {
787 return $this->value('size', $fieldXML->html
);
789 // Infer from <length> tag if <size> was not explicitly set or was invalid
790 // This map is slightly different from CRM_Core_Form_Renderer::$_sizeMapper
791 // Because we usually want fields to render as smaller than their maxlength
801 foreach ($sizes as $length => $name) {
802 if ($fieldXML->length
<= $length) {
803 return "CRM_Utils_Type::$name";
806 return 'CRM_Utils_Type::HUGE';