doctrine2/manual/docs/en/utilities/facade.txt

+++ Creating & Dropping Databases

Doctrine offers the ability to create and drop your databases from your defined Doctrine connections. The only trick to using it is that the name of your Doctrine connection must be the name of your database. This is required due to the fact that PDO does not offer a method for retrieving the name of the database you are connected to. So in order to create and drop the database Doctrine itself must be aware of the name of the database.

+++ Convenience Methods

Doctrine offers static convenience methods available in the main Doctrine class. These methods perform some of the most used functionality of Doctrine with one method. Most of these methods are using in the Doctrine_Task system. These tasks are also what are executed from the Doctrine_Cli.

<code type="php">
// Turn debug on/off and check for whether it is on/off
Doctrine::debug(true);

if (Doctrine::debug()) {
    echo 'debugging is on';
} else {
    echo 'debugging is off';
}

// Get the path to your Doctrine libraries
$path = Doctrine::getPath();

// Load your models so that they are present and loaded for Doctrine to work with
// Returns an array of the Doctrine_Records that were found and loaded
$models = Doctrine::loadModels('/path/to/models');
print_r($models);

// Get array of all the models loaded and present to Doctrine
$models = Doctrine::getLoadedModels();

// Pass an array of classes to the above method and it will filter out the ones that are not Doctrine_Records
$models = Doctrine::getLoadedModels(array('User', 'Formatter', 'Doctrine_Record'));
print_r($models); // would return array('User') because Formatter and Doctrine_Record are not Doctrine_Records

// Get Doctrine_Connection object for an actual table name
$conn = Doctrine::getConnectionByTableName('user'); // returns the connection object that the table name is associated with

// Generate your models from an existing database
Doctrine::generateModelsFromDb('/path/to/generate/models');

// Generate YAML schema from an existing database
Doctrine::generateYamlFromDb('/path/to/dump/schema.yml');

// Generate your models from YAML schema
Doctrine::generateModelsFromYaml('/path/to/schema.yml', '/path/to/generate/models');

// Create all your tables from an existing set of models
Doctrine::createTablesFromModels('/path/to/models');

// Create the tables supplied in the array
Doctrine::createTablesFromArray(array('User', 'Phoneumber'));

// Generate string of sql commands from an existing set of models
Doctrine::generateSqlFromModels('/path/to/models');

// Generate YAML schema from an existing set of models
Doctrine::generateYamlFromModels('/path/to/schema.yml', '/path/to/models');

// It is required your connection name to be the same as your database name in order for the drop/create functionality below to work.

// Create all databases for connections.
Doctrine::createDatabases();

// Drop all databases for connections
Doctrine::dropDatabases();

// Dump all data for your models to a yaml fixtures file
// 2nd argument is a bool value for whether or not to generate individual fixture files for each model. If true you need to specify a folder instead of a file.
Doctrine::dumpData('/path/to/dump/data.yml', true);

// Load data from yaml fixtures files
// 2nd argument is a bool value for whether or not to append the data when loading or delete all data first before loading
Doctrine::loadData('/path/to/fixture/files', true);

// Run a migration process for a set of migration classes
$num = 5; // migrate to version #5
Doctrine::migration('/path/to/migrations', $num);

// Generate a blank migration class template
Doctrine::generateMigrationClass('ClassName', '/path/to/migrations');

// Generate all migration classes for an existing database
Doctrine::generateMigrationsFromDb('/path/to/migrations');

// Generate all migration classes for an existing set of models
// 2nd argument is optional if you have already loaded your models using loadModels()
Doctrine::generateMigrationsFromModels('/path/to/migrations', '/path/to/models');

// Get Doctrine_Table instance for a model
$userTable = Doctrine::getTable('User');

// Compile doctrine in to a single php file
$drivers = array('mysql'); // specify the array of drivers you want to include in this compiled version
Doctrine::compile('/path/to/write/compiled/doctrine', $drivers);

// Dump doctrine objects for debugging
$conn = Doctrine_Manager::connection();
Doctrine::dump($conn);
</code>

+++ Tasks

Tasks are classes which bundle some of the core convenience methods in to tasks that can be easily executed by setting the required arguments. These tasks are directly used in the Doctrine command line interface.

<code>
BuildAll
BuildAllLoad
BuildAllReload
Compile
CreateDb
CreateTables
Dql
DropDb
DumpData
Exception
GenerateMigration
GenerateMigrationsDb
GenerateMigrationsModels
GenerateModelsDb
GenerateModelsYaml
GenerateSql
GenerateYamlDb
GenerateYamlModels
LoadData
LoadDummyData
Migrate
RebuildDb
</code>

You can read below about how to execute Doctrine Tasks standalone in your own scripts.