protected function _initDoctrine()
{
$config = $this->getOptions();
$manager = Doctrine_Manager::getInstance();
$manager->setAttribute(Doctrine_Core::ATTR_AUTO_ACCESSOR_OVERRIDE, true);
$manager->setAttribute(Doctrine_Core::ATTR_DEFAULT_TABLE_CHARSET, 'utf8');
$manager->setAttribute(Doctrine_Core::ATTR_DEFAULT_TABLE_COLLATE, 'utf8_unicode_ci');
$manager->setAttribute(Doctrine_Core::ATTR_DEFAULT_TABLE_TYPE, 'INNODB');
$manager->setAttribute(Doctrine_Core::ATTR_USE_NATIVE_ENUM, true);
$manager->setAttribute(Doctrine_Core::ATTR_AUTOLOAD_TABLE_CLASSES, false);
$manager->setAttribute(Doctrine_Core::ATTR_MODEL_LOADING, Doctrine_Core::MODEL_LOADING_CONSERVATIVE);
// enable validation on save()
$manager->setAttribute(Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_ALL);
$manager->setAttribute(Doctrine_Core::ATTR_USE_DQL_CALLBACKS, true);
if ($config['doctrine']['cache']) {
$cacheDriver = new Doctrine_Cache_Apc();
$manager->setAttribute(Doctrine_Core::ATTR_QUERY_CACHE, $cacheDriver);
}
$conn = Doctrine_Manager::connection($config['doctrine']['dsn']);
$conn->setCharset('utf8');
try {
Doctrine_Core::createDatabases();
} catch (Exception $e) {
}
$conn = Doctrine_Core::loadModels(APPLICATION_PATH . '/models', Doctrine_Core::MODEL_LOADING_AGGRESSIVE);
$conn = Doctrine_Core::createTablesFromModels();
return $manager;
}
public function generateTables()
{
$this->removeTables();
Doctrine_Core::createTablesFromModels(MODELS);
FlashComponent::set('info', 'Generate Table terminé.');
$this->redirect(array('action' => 'index'));
}
protected function setUp()
{
$this->classLoader = Zend_Loader_Autoloader::getInstance();
$this->classLoader->registerNamespace('Doctrine_');
if (!class_exists('Doctrine_Manager')) {
$this->markTestSkipped('Doctrine 1.2.x installation not found in include_path');
}
// create in memory connection
Doctrine_Manager::connection("sqlite::memory:", 'doctrine');
// create tables for account model
Doctrine_Core::createTablesFromModels(dirname(__FILE__) . "/_files/models/");
}
/**
* Create Tables from models for given module.
*
* @param string $modname Module name.
* @param string $path Optional force path to Model directory (used by plugins).
*
* @return void
*/
public static function createTablesFromModels($modname, $path = null)
{
$modname = isset($modname) ? strtolower((string) $modname) : '';
$modinfo = ModUtil::getInfoFromName($modname);
$osdir = DataUtil::formatForOS($modinfo['directory']);
$base = $modinfo['type'] == ModUtil::TYPE_MODULE ? 'modules' : 'system';
$dm = Doctrine_Manager::getInstance();
$save = $dm->getAttribute(Doctrine_Core::ATTR_MODEL_LOADING);
$dm->setAttribute(Doctrine_Core::ATTR_MODEL_LOADING, Doctrine_Core::MODEL_LOADING_AGGRESSIVE);
$path = is_null($path) ? "{$base}/{$osdir}/lib/{$osdir}/Model" : "{$base}/{$osdir}/{$path}";
Doctrine_Core::createTablesFromModels(realpath($path));
$dm->setAttribute(Doctrine_Core::ATTR_MODEL_LOADING, $save);
}
static function setUp()
{
try {
Doctrine_Core::dropDatabases();
} catch (Exception $e) {
}
Doctrine_Manager::connection()->clear();
try {
Doctrine_Core::createDatabases();
} catch (Exception $e) {
}
Doctrine_Core::loadModels(APPLICATION_PATH . '/models', Doctrine_Core::MODEL_LOADING_AGGRESSIVE);
Doctrine_Core::createTablesFromModels();
}
function initialize()
{
// bootstrap Doctrine
require_once dirname(__FILE__) . '/vendor/doctrine/doctrine1/lib/Doctrine.php';
spl_autoload_register(array('Doctrine', 'autoload'));
$this->manager = Doctrine_Manager::getInstance();
// set connection
$this->con = Doctrine_Manager::connection('sqlite::memory:');
// setup autoloading
$this->manager->setAttribute(Doctrine_Core::ATTR_MODEL_LOADING, Doctrine_Core::MODEL_LOADING_CONSERVATIVE);
spl_autoload_register(array('Doctrine', 'modelsAutoload'));
// import db
try {
$this->manager->dropDatabases();
} catch (Doctrine_Export_Exception $e) {
// do nothing; it's probably the first time the test is run
}
$this->manager->createDatabases();
Doctrine_Core::createTablesFromModels(dirname(__FILE__) . '/models');
}
public function setUp()
{
if (!extension_loaded('pdo_sqlite')) {
$this->markTestSkipped('Requires PDO_Sqlite extension');
}
$this->_request = new Zend_Db_Profiler_FirebugTest_Request();
$this->_response = new Zend_Db_Profiler_FirebugTest_Response();
$channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();
$channel->setRequest($this->_request);
$channel->setResponse($this->_response);
// try to autoload doctrine
Zend_Loader_Autoloader::getInstance()->registerNamespace('Doctrine_');
if (!class_exists('Doctrine_Manager')) {
$this->markTestSkipped('Doctrine 1.2.x installation not found in include_path');
}
// create in memory connection
Doctrine_Manager::connection("sqlite::memory:", 'doctrine');
// instantiate plugin
$this->_plugin = new Zle_Controller_Plugin_DoctrineProfilerFirebug();
// create tables for account model
Doctrine_Core::createTablesFromModels(dirname(__FILE__) . "/_files/models/");
}
/**
* Create the ShineISP Database
*/
public static function createDb($installsampledata = true)
{
try {
$dbconfig = Shineisp_Main::databaseConfig();
$dsn = Shineisp_Main::getDSN();
$conn = Doctrine_Manager::connection($dsn, 'doctrine');
$conn->execute('SHOW TABLES');
# Lazy loading of the connection. If I execute a simple command the connection to the database starts.
$conn->setAttribute(Doctrine::ATTR_USE_NATIVE_ENUM, true);
$conn->setCharset('UTF8');
$dbh = $conn->getDbh();
$models = Doctrine::getLoadedModels();
// Set the current connection
$manager = Doctrine_Manager::getInstance()->setCurrentConnection('doctrine');
if ($conn->isConnected()) {
$migration = new Doctrine_Migration(APPLICATION_PATH . '/configs/migrations');
// Get the latest version set in the migrations directory
$latestversion = $migration->getLatestVersion();
if (empty($latestversion)) {
$latestversion = 0;
}
// Clean the database
$conn->execute('SET FOREIGN_KEY_CHECKS = 0');
foreach ($models as $model) {
$tablename = Doctrine::getTable($model)->getTableName();
$dbh->query("DROP TABLE IF EXISTS {$tablename}");
}
// Create the migration_version table
Doctrine_Manager::getInstance()->getCurrentConnection()->execute('DROP TABLE IF EXISTS `migration_version`;CREATE TABLE `migration_version` (`version` int(11) DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=latin1;INSERT INTO `migration_version` VALUES (' . $latestversion . ')');
// Create all the tables in the database
Doctrine_Core::createTablesFromModels(APPLICATION_PATH . '/models');
// Common resources
Doctrine_Core::loadData(APPLICATION_PATH . '/configs/data/fixtures/commons/', true);
// Sample data
if ($installsampledata) {
$import = new Doctrine_Data_Import(APPLICATION_PATH . '/configs/data/fixtures/');
$import->setFormat('yml');
$import->setModels($models);
$import->doImport(true);
}
$conn->execute('SET FOREIGN_KEY_CHECKS = 1');
// Update the version in the config.xml file previously created
Settings::saveConfig($dbconfig, $latestversion);
} else {
echo "No Connection found";
}
} catch (Exception $e) {
die($e);
}
// return the latest version
return $latestversion;
}
public function execute()
{
Doctrine_Core::createTablesFromModels($this->getArgument('models_path'));
$this->notify('Created tables successfully');
}
public function testExportModelFromDirectory()
{
Doctrine_Core::createTablesFromModels(dirname(__FILE__) . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'models' . DIRECTORY_SEPARATOR . 'export');
$this->assertEqual($this->adapter->pop(), 'COMMIT');
$this->assertEqual($this->adapter->pop(), 'ALTER TABLE cms__category_languages ADD CONSTRAINT cms__category_languages_category_id_cms__category_id FOREIGN KEY (category_id) REFERENCES cms__category(id) ON DELETE CASCADE');
$this->assertEqual($this->adapter->pop(), 'CREATE TABLE cms__category_languages (id BIGINT AUTO_INCREMENT, name TEXT, category_id BIGINT, language_id BIGINT, INDEX index_category_idx (category_id), INDEX index_language_idx (language_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = INNODB');
$this->assertEqual($this->adapter->pop(), 'CREATE TABLE cms__category (id BIGINT AUTO_INCREMENT, created DATETIME, parent BIGINT, position MEDIUMINT, active BIGINT, INDEX index_parent_idx (parent), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE = INNODB');
$this->assertEqual($this->adapter->pop(), 'BEGIN TRANSACTION');
}
public function exec()
{
echo Doctrine_Core::createTablesFromModels($this->getOptionsValue('models-path'));
}
<?php
$_test_dir = realpath(dirname(__FILE__) . '/..');
// configuration
require_once dirname(__FILE__) . '/../../../../config/ProjectConfiguration.class.php';
$configuration = ProjectConfiguration::hasActive() ? ProjectConfiguration::getActive() : new ProjectConfiguration(realpath($_test_dir . '/..'));
// autoloader
$autoload = sfSimpleAutoload::getInstance(sfConfig::get('sf_cache_dir') . '/project_autoload.cache');
$autoload->loadConfiguration(sfFinder::type('file')->name('autoload.yml')->in(array(sfConfig::get('sf_symfony_lib_dir') . '/config/config', sfConfig::get('sf_config_dir'))));
$autoload->register();
// lime
include $configuration->getSymfonyLibDir() . '/vendor/lime/lime.php';
$configuration = ProjectConfiguration::getApplicationConfiguration('frontend', 'test', true);
//Remove test dirs
$rootdir = sfConfig::get('sf_web_dir') . DIRECTORY_SEPARATOR . 'test_root';
if (is_dir($rootdir)) {
$files = sfFinder::type('any')->maxdepth(4)->in($rootdir);
array_unshift($files, $rootdir);
$fs = new sfFileSystem();
$fs->remove($files);
}
new sfDatabaseManager($configuration);
Doctrine_Core::dropDatabases();
Doctrine_Core::createDatabases();
Doctrine_Core::createTablesFromModels(sfConfig::get('sf_lib_dir') . '/model');
<?php
if (array_key_exists(1, $argv)) {
$env = $argv[1];
} else {
$env = 'production';
}
defined('BASE_PATH') || define('BASE_PATH', realpath(dirname(__FILE__) . '/..'));
// Ensure library/ is on include_path
set_include_path(implode(PATH_SEPARATOR, array(realpath(BASE_PATH . '/library'), get_include_path())));
/** Zend_Application */
require_once 'Zend/Application.php';
// Create application, bootstrap, and run
$config = array('config' => array(realpath(BASE_PATH . '/configs/application.ini')));
$application = new Zend_Application($env, $config);
$dbConnection = $application->getBootstrap()->bootstrap('Doctrine');
try {
Doctrine_Core::dropDatabases();
} catch (Doctrine_Connection_Mysql_Exception $e) {
error_log('The database did not exists');
}
Doctrine_Core::createDatabases();
$options = $application->getOptions();
$ymlPath = realpath(BASE_PATH . '/Scripts/Yaml/Schema/Koryukan.yml');
$modelsOptions = array('suffix' => '.php', 'generateTableClasses' => true, 'classPrefix' => 'Koryukan_Db_', 'classPrefixFiles' => false, 'baseClassPrefix' => 'Base', 'baseClassesDirectory' => '');
Doctrine_Core::generateModelsFromYaml($ymlPath, $options['db']['objectsPath'], $modelsOptions);
Doctrine_Core::createTablesFromModels($options['db']['objectsPath']);
Doctrine_Core::loadData(BASE_PATH . '/Scripts/Yaml/Data/news.yml');
Doctrine_Core::loadData(BASE_PATH . '/Scripts/Yaml/Data/storeItems.yml');
Doctrine_Core::loadData(BASE_PATH . '/Scripts/Yaml/Data/images.yml');
Doctrine_Core::loadData(BASE_PATH . '/Scripts/Yaml/Data/security.yml');
/**
* Blog - Database Generator
*
* This file contains a script for generating the database for the blog demo.
* Running this script from command line as follows will generate a new database:
*
* <code>
* php generate.php
* </code>
*
* LICENSE
*
* This file is part of the Breeze Framework package and is subject to the new
* BSD license. For full copyright and license information, please see the
* LICENSE file that is distributed with this package.
*
* @author Jeff Welch <*****@*****.**>
* @category Blog
* @package Databases
* @copyright Copyright (c) 2010, Breeze Framework
* @license New BSD License
* @version $Id$
*/
define('BREEZE_APPLICATION', realpath(dirname(__FILE__) . '/..'));
require_once BREEZE_APPLICATION . '/models/Doctrine.php';
Doctrine_Core::dropDatabases();
Doctrine_Core::createDatabases();
Doctrine_Core::generateModelsFromYaml(BREEZE_APPLICATION . '/databases/schema.yml', BREEZE_APPLICATION . '/models');
Doctrine_Core::createTablesFromModels(BREEZE_APPLICATION . '/models');
public static function syncdb($apps = null, $drop_database = false, $append = true)
{
if (!self::$inited || !self::$connections) {
self::init();
}
if (!$apps) {
$apps = ini('base/INSTALLED_APPS');
}
if (!$apps) {
return true;
}
if ($drop_database) {
Doctrine_Core::dropDatabases();
Doctrine_Core::createDatabases();
}
foreach ((array) $apps as $k => $app) {
$app = str_replace('.', '/', $app);
try {
/*
* Generate the models
*/
if (isset($_GET['use_yaml'])) {
$schemas = Package::get_file(sprintf('applications/%s/%s', $app, 'schemas.yml'));
if (!is_file($schemas)) {
continue;
}
Doctrine_Core::generateModelsFromYaml($schemas, Package::get_folder(sprintf('applications/%s/models', $app)), self::$_generate_options);
} else {
try {
import(sprintf('applications/%s/models/generated/*', $app));
} catch (DoesNotExistsException $e) {
continue;
}
}
/*
* syncdb
*/
Doctrine_Core::createTablesFromModels(Package::get_folder(sprintf('applications/%s/models', $app)), self::$_generate_options);
/*
* Insert test data
*/
$dir = Package::get_folder(sprintf('applications/%s/fixtures', $app));
if (is_dir($dir)) {
Doctrine_Core::loadData($dir, $append);
}
} catch (PDOException $e) {
continue;
}
}
}
<?php
require_once 'bootstrap.php';
Doctrine_Core::dropDatabases();
Doctrine_Core::createDatabases();
Doctrine_Core::createTablesFromModels('models');
