/** * Creates the needed DB schema using Doctrine's SchemaTool. If tables already * exist, this will throw an exception. * * @param string $outputPathAndFilename A file to write SQL to, instead of executing it * @return string */ public function createSchema($outputPathAndFilename = null) { $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->entityManager); if ($outputPathAndFilename === null) { $schemaTool->createSchema($this->entityManager->getMetadataFactory()->getAllMetadata()); } else { file_put_contents($outputPathAndFilename, implode(PHP_EOL, $schemaTool->getCreateSchemaSql($this->entityManager->getMetadataFactory()->getAllMetadata()))); } }
public function create_dump_sql() { $driver = $this->em->getConfiguration()->getMetadataDriverImpl(); $entities_names = $driver->getAllClassNames(); $entities_metadata = array(); foreach ($entities_names as $name) { array_push($entities_metadata, $this->em->getClassMetadata($name)); } $tool = new \Doctrine\ORM\Tools\SchemaTool($this->em); return $tool->getCreateSchemaSql($entities_metadata); }
/** * @param Configuration $cliConfig */ protected function _doRun(\Doctrine\Common\Cli\Configuration $cliConfig) { if (!is_writable(dirname($this->installSqlFile))) { throw new \BuildException("Directory to write Install Sql File into is not writable."); } $em = $cliConfig->getAttribute('em'); $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($em); $cmf = $em->getMetadataFactory(); $classes = $cmf->getAllMetadata(); $sql = $schemaTool->getCreateSchemaSql($classes); $code = "<?php\n\nreturn " . var_export($sql, true) . ";\n"; file_put_contents($this->installSqlFile, $code); $this->log("Wrote the Array of SQL statements to create schema to file " . $this->installSqlFile); }
/** * @see Console\Command\Command */ public function execute(InputInterface $input, OutputInterface $output) { $container = $this->getApplication()->getKernel()->getContainer(); $em = $container->getService('em'); $entityMetaClasses = array(); foreach ($input->getArgument('entity') as $entity) { $entityMetaClasses[] = $em->getClassMetadata($entity); } $tool = new \Doctrine\ORM\Tools\SchemaTool($em); if ($input->getOption('alter')) { $schema = $tool->getUpdateSchemaSql($entityMetaClasses, true); } else { $schema = $tool->getCreateSchemaSql($entityMetaClasses); } array_walk($schema, function (&$value) { $value = $value . ';'; }); $output->writeln($schema); }
/** * Secret function, to create/update database schema from doctrine entities * @param type $mode * @return type */ function db_schema($mode = "update") { try { $this->em = $this->doctrine->em; $tool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory(); $cmf->setEntityManager($this->em); $metadata = $cmf->getAllMetadata(); if ($mode == "create") { $queries = $tool->getCreateSchemaSql($metadata); } else { $queries = $tool->getUpdateSchemaSql($metadata); } echo "Total queries: " . count($queries) . "<br /><br />"; for ($i = 0; $i < count($queries); $i++) { $this->db->query($queries[$i]); echo $queries[$i] . "<br /><br />Execution Successfull: " . ($i + 1) . "<br /><br />"; } } catch (Exception $err) { log_message("error", $err->getMessage()); return show_error($err->getMessage()); } }
public function createSchema() { $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $classes = $this->em->getMetadataFactory()->getAllMetadata(); $sql = $schemaTool->getCreateSchemaSql($classes); $schemaTool->createSchema($classes, true); return $sql; }
/** * Get structures to save when module is disabled * * @param string $author Module author * @param string $name Module name * * @return array */ public static function getModuleProtectedStructures($author, $name) { $tables = array(); $columns = array(); $path = static::getAbsoluteDir($author, $name) . 'Model'; if (\Includes\Utils\FileManager::isExists($path)) { $filter = new \Includes\Utils\FileFilter($path, '/.*\\.php$/Si'); foreach ($filter->getIterator() as $path => $data) { // DO NOT call "getInterfaces()" after the "getFullClassName()" // DO NOT use reflection to get interfaces $interfaces = \Includes\Decorator\Utils\Tokenizer::getInterfaces($path); $class = \Includes\Decorator\Utils\Tokenizer::getFullClassName($path); // Do 'autoload' checking first since the class_exists tries to use autoloader // but fails into "cannot include file" warning when model class is not set to use (LC_Dependencies issue) if (\Includes\Autoloader::checkAutoload($class) && class_exists($class)) { // $reflectionClass = new \ReflectionClass($class); if ($class && is_subclass_of($class, '\\XLite\\Model\\AEntity')) { $class = ltrim($class, '\\'); $len = strlen(\Includes\Utils\Database::getTablesPrefix()); // DO NOT remove leading backslash in interface name if (in_array('\\XLite\\Base\\IDecorator', $interfaces)) { $parent = \Includes\Decorator\Utils\Tokenizer::getParentClassName($path); $parent = ltrim($parent, '\\'); $metadata = \XLite\Core\Database::getEM()->getClassMetadata($parent); $table = substr($metadata->getTableName(), $len); $tool = new \Doctrine\ORM\Tools\SchemaTool(\XLite\Core\Database::getEM()); $schema = $tool->getCreateSchemaSql(array($metadata)); foreach ((array) $metadata->reflFields as $field => $reflection) { $pattern = '/(?:, |\\()(' . $field . ' .+)(?:, [A-Za-z]|\\) ENGINE)/USsi'; if ($reflection->class === $class && !empty($metadata->fieldMappings[$field]) && preg_match($pattern, $schema[0], $matches)) { $columns[$table][$field] = $matches[1]; } } foreach ($metadata->associationMappings as $mapping) { if ($metadata->reflFields[$mapping['fieldName']]->class === $class) { if (isset($mapping['joinTable']) && $mapping['joinTable']) { $tables[] = substr($mapping['joinTable']['name'], $len); } elseif (isset($mapping['joinColumns']) && $mapping['joinColumns']) { foreach ($mapping['joinColumns'] as $col) { $pattern = '/(?:, |\\()(' . $col['name'] . ' .+)(?:, [A-Za-z]|\\) ENGINE)/USsi'; if (preg_match($pattern, $schema[0], $matches)) { $columns[$table][$col['name']] = $matches[1]; } } } } } } elseif (\XLite\Core\Database::getRepo($class)->canDisableTable()) { $tables[] = substr(\XLite\Core\Database::getEM()->getClassMetadata($class)->getTableName(), $len); $metadata = \XLite\Core\Database::getEM()->getClassMetadata($class); foreach ($metadata->associationMappings as $mapping) { if (isset($mapping['joinTable']) && $mapping['joinTable']) { $tables[] = substr($mapping['joinTable']['name'], $len); } } } } } } } return array('tables' => $tables, 'columns' => $columns); }
/** * Get DB schema * * @param string $mode Schema generation mode OPTIONAL * * @return array(string) */ public function getDBSchema($mode = self::SCHEMA_CREATE) { $tool = new \Doctrine\ORM\Tools\SchemaTool(static::$em); $schemas = array(); $rawSchemas = null; $postprocessMethod = null; if (static::SCHEMA_CREATE == $mode) { $rawSchemas = $tool->getCreateSchemaSql($this->getAllMetadata()); $postprocessMethod = 'postprocessCreateSchema'; } elseif (static::SCHEMA_UPDATE == $mode) { $rawSchemas = $tool->getUpdateSchemaSql($this->getAllMetadata()); $postprocessMethod = 'postprocessUpdateSchema'; } elseif (static::SCHEMA_DELETE == $mode) { $rawSchemas = $tool->getDropSchemaSql($this->getAllMetadata()); $postprocessMethod = 'postprocessDropSchema'; } if ($rawSchemas) { foreach ($rawSchemas as $schema) { // $postprocessMethod detected by $mode $schema = $this->{$postprocessMethod}($schema); if (is_array($schema)) { $schemas = array_merge($schemas, $schema); } elseif (isset($schema) && $schema) { $schemas[] = $schema; } } foreach (static::$em->getMetadataFactory()->getAllMetadata() as $cmd) { if (!$cmd->isMappedSuperclass) { $schemas = static::getRepo($cmd->name)->processSchema($schemas, $mode); } } $schemas = array_map('trim', $schemas); $schemas = preg_grep('/^.+$/Ss', $schemas); } return $schemas; }
/** * Returns schema from doctrine * * @param string $mode Schema generation mode OPTIONAL * * @return array */ protected function getDBSchemaFromDoctrine($mode = self::SCHEMA_CREATE) { $tool = new \Doctrine\ORM\Tools\SchemaTool(static::$em); switch ($mode) { case static::SCHEMA_CREATE: $result = $tool->getCreateSchemaSql($this->getAllMetadata()); break; case static::SCHEMA_UPDATE: $result = $tool->getUpdateSchemaSql($this->getAllMetadata()); break; case static::SCHEMA_DELETE: $result = $tool->getDropSchemaSql($this->getAllMetadata()); break; default: $result = array(); } return array_unique($result); }