/** * Returns an array with SQL DDL statements that creates the database definition in $dbSchema * * Converts the schema definition contained in $dbSchema to DDL SQL. This * SQL can be used to create tables in an existing database according to * the definition. The SQL queries are returned as an array. * * @param ezcDbSchema $dbSchema * @return array(string) */ public function convertToDDL(ezcDbSchema $dbSchema) { $this->schema = $dbSchema->getSchema(); // reset queries $this->queries = array(); $this->context = array(); $this->generateSchemaAsSql(); return $this->queries; }
/** * Saves the schema definition in $schema to the file $file. * @todo throw exception when file can not be opened * * @param string $file * @param ezcDbSchema $dbSchema */ public function saveToFile($file, ezcDbSchema $dbSchema) { $schema = $dbSchema->getSchema(); $data = $dbSchema->getData(); $fileData = '<?php return ' . var_export(array($schema, $data), true) . '; ?>'; if (!@file_put_contents($file, (string) $fileData)) { throw new ezcBaseFilePermissionException($file, ezcBaseFileException::WRITE); } }
/** * Writes the schema definition in $dbSchema to files located in $dir. * This method dumps the given schema to PersistentObject definitions, which * will be located in the given directory. * * @param string $dir The directory to store definitions in. * @param ezcDbSchema $dbSchema The schema object to create defs for. * * @throws ezcBaseFileNotFoundException If the given directory could not be * found. * @throws ezcBaseFilePermissionException If the given directory is not * writable. */ public function saveToFile($dir, ezcDbSchema $dbSchema) { if (!is_dir($dir)) { throw new ezcBaseFileNotFoundException($dir, 'directory'); } if (!is_writable($dir)) { throw new ezcBaseFilePermissionException($dir, ezcBaseFileException::WRITE); } $schema = $dbSchema->getSchema(); foreach ($schema as $tableName => $table) { $this->writeTable($dir, $tableName, $table); } }
/** * Validates if all the types used in the $schema are supported. * * This method loops over all the fields in a table and checks whether the * type that is used for each field is supported. It will return an array * containing error strings for each non-supported type that it finds. * * @param ezcDbSchema $schema * @return array(string) */ public static function validate(ezcDbSchema $schema) { $errors = array(); /* For each table we check all field's types. */ foreach ($schema->getSchema() as $tableName => $table) { foreach ($table->fields as $fieldName => $field) { if (!in_array($field->type, ezcDbSchema::$supportedTypes)) { $errors[] = "Field '{$tableName}:{$fieldName}' uses the unsupported type '{$field->type}'."; } } } return $errors; }
/** * Validates if all the fields used in all indexes exist. * * This method loops over all the fields in the indexes of each table and * checks whether the fields that is used in an index is also defined in * the table definition. It will return an array containing error strings * for each non-supported type that it finds. * * @param ezcDbSchema $schema * @return array(string) */ public static function validate(ezcDbSchema $schema) { $errors = array(); /* For each table we first retrieve all the field names, and then check * per index whether the fields it references exist */ foreach ($schema->getSchema() as $tableName => $table) { $fields = array_keys($table->fields); foreach ($table->indexes as $indexName => $index) { foreach ($index->indexFields as $indexFieldName => $dummy) { if (!in_array($indexFieldName, $fields)) { $errors[] = "Index '{$tableName}:{$indexName}' references unknown field name '{$tableName}:{$indexFieldName}'."; } } } } return $errors; }
/** * Validates if all the index names used are unique accross the schema. * * This method loops over all the indexes in all tables and checks whether * they have been used before. * * @param ezcDbSchema $schema * @return array(string) */ public static function validate(ezcDbSchema $schema) { $indexes = array(); $errors = array(); /* For each table we check all auto increment fields. */ foreach ($schema->getSchema() as $tableName => $table) { foreach ($table->indexes as $indexName => $dummy) { $indexes[$indexName][] = $tableName; } } foreach ($indexes as $indexName => $tableList) { if (count($tableList) > 1) { $errors[] = "The index name '{$indexName}' is not unique. It exists for the tables: '" . join("', '", $tableList) . "'."; } } return $errors; }
/** * Writes the given $schema to $dir using $template. * * Iterates through all tables in $schema, sends each of them to a {@link * ezcTemplate} with $template and writes the result to $dir with the file * name returned by the template. * * @param ezcDbSchema $schema * @param string $template * @param mixed $dir */ public function write(ezcDbSchema $schema, $template, $dir) { $tplConf = ezcTemplateConfiguration::getInstance(); $tplConf->templatePath = $this->properties['options']->templatePath; $tplConf->compilePath = $this->properties['options']->templateCompilePath; $tpl = new ezcTemplate(); $tpl->send->classPrefix = $this->properties['options']->classPrefix; foreach ($schema->getSchema() as $tableName => $tableSchema) { $tpl->send->schema = $tableSchema; $tpl->send->tableName = $tableName; $content = $tpl->process($template); $fileName = $dir . '/' . $tpl->receive->fileName; if (!$this->properties['options']->overwrite && file_exists($fileName)) { throw new ezcPersistentObjectSchemaOverwriteException($fileName); } file_put_contents($fileName, $content); } }
/** * Validates if all the types used in the $schema are supported. * * This method loops over all the fields in a table and checks whether the * type that is used for each field is supported. It will return an array * containing error strings for each non-supported type that it finds. * * @param ezcDbSchema $schema * @return array(string) */ public static function validate(ezcDbSchema $schema) { $errors = array(); /* For each table we check all auto increment fields. */ foreach ($schema->getSchema() as $tableName => $table) { foreach ($table->fields as $fieldName => $field) { if ($field->autoIncrement === true) { $found = false; // Loop over de indexes to see if there is a primary foreach ($table->indexes as $indexName => $index) { if ($index->primary === true) { $found = true; break; } } if (!$found) { $errors[] = "Field '{$tableName}:{$fieldName}' is auto increment but there is no primary index defined."; } } } } return $errors; }
/** * Writes the schema definition in $dbSchema to the file $file. * * @param string $file * @param ezcDbSchema $dbSchema * @todo throw exception when file can not be opened */ public function saveToFile($file, ezcDbSchema $dbSchema) { $schema = $dbSchema->getSchema(); $data = $dbSchema->getData(); $this->writer = new XMLWriter(); if (!@$this->writer->openUri($file)) { throw new ezcBaseFilePermissionException($file, ezcBaseFileException::WRITE); } $this->writer->startDocument('1.0', 'utf-8'); $this->writer->setIndent(true); $this->writer->startElement('database'); foreach ($schema as $tableName => $table) { $this->writer->flush(); $this->writeTable($tableName, $table); } $this->writer->endElement(); $this->writer->endDocument(); }
/** * Filter properties that accept a null value. * * Note that ToOne relations involve a *virtual* property that * accepts a NULL value; except if the ToOne is mapped to a local * *table* column that does not accept null values. * * The $out parameter specifies if the filtered properties should be * deleted from the list, or if it should be the only properties left. * If $out is *true*, the filtered properties are removed from the list * and if it's false, all the non-filtered properties are removed. * * <code> * <?php * // Remove all properties accepting a null value : * $list->filterNull(); * * // Remove all properties that don't accept a null value : * $list->filterNull( false ); * ?> * </code> * * @param $out bool True to filter out all the properties accepting * null value; false to remove all other. * @return aiiPersistentObjectFilterablePropertyList $this */ public function filterNull($out = true) { $schema = $this->schema->getSchema(); foreach ($this->properties as $name => $def) { if (array_key_exists($name, $schema[$this->def->table]->fields)) { $notNull = $schema[$this->def->table]->fields[$name]->notNull; } else { $notNull = $def->propertyType != ezcPersistentObjectProperty::PHP_TYPE_OBJECT; } if ($out != $notNull) { if (array_key_exists($name, $this)) { unset($this[$name]); } } } return $this; }