Utilities

// Defining initial variables
$ currentPage    = 1;
$ resultsPerPage = 50;

// Creating pager object
$ pager = new Doctrine_Pager(
    Doctrine_Query::create()
        ->from( 'User u' )
        ->leftJoin( 'u.Group g' )
        ->orderby( 'u.username ASC' ),
    $currentPage, // Current page of request
    $resultsPerPage, // (Optional) Number of results per page. Default is 25
);

$ pager->getExecuted();

$ items = $pager->execute( [$args = array() [, $fetchType = null]] );

foreach ( $items as $item )
{
    // ...
}

$ pager->setCountQuery( $query [, $params = null] );

// ...
$ rs = $pager->execute();

$ pager->setCountQueryParams( [$params = array() [, $append = false]] );

// Returns the check if Pager was already executed
$ pager->getExecuted();

// Return the total number of itens found on query search
$ pager->getNumResults();

// Return the first page (always 1)
$ pager->getFirstPage();

// Return the total number of pages
$ pager->getLastPage();

// Return the current page
$ pager->getPage();

// Defines a new current page (need to call execute again to adjust offsets and values)
$ pager->setPage( $page );

// Return the next page
$ pager->getNextPage();

// Return the previous page
$ pager->getPreviousPage();

// Return the first indice of current page
$ pager->getFirstIndice();

// Return the last indice of current page
$ pager->getLastIndice();

// Return true if it's necessary to paginate or false if not
$ pager->haveToPaginate();

// Return the maximum number of records per page
$ pager->getMaxPerPage();

// Defined a new maximum number of records per page (need to call execute again to adjust offset and values)
$ pager->setMaxPerPage( $maxPerPage );

// Returns the number of itens in current page
$ pager->getResultsInPage();

// Returns the Doctrine_Query object that is used to make the count results to pager
$ pager->getCountQuery();

// Defines the counter query to be used by pager
$ pager->setCountQuery( $query, $params = null );

// Returns the params to be used by counter Doctrine_Query (return $defaultParams if no param is defined)
$ pager->getCountQueryParams( $defaultParams = array() );

// Defines the params to be used by counter Doctrine_Query
$ pager->setCountQueryParams( $params = array(), $append = false );

// Return the Doctrine_Query object
$ pager->getQuery();

// Return an associated Doctrine_Pager_Range_* instance
$ pager->getRange( $rangeStyle, $options = array() );

// $this refers to an instance of Doctrine_Pager_Layout

// Defines a mask replacement. When parsing template, it converts replacement
// masks into new ones (or values), allowing to change masks behavior on the fly
$ this->addMaskReplacement( $oldMask, $newMask, $asValue = false );

// Remove a mask replacement
$ this->removeMaskReplacement( $oldMask );

// Remove all mask replacements
$ this->cleanMaskReplacements();

// Parses the template and returns the string of a processed page
$ this->processPage( $options = array() ); // Needs at least page_number offset in $options array

// Protected methods, although very useful

// Parse the template of a given page and return the processed template
$ this->_parseTemplate( $options = array() );

// Parse the url mask to return the correct template depending of the options sent
// Already process the mask replacements assigned
$ this->_parseUrlTemplate( $options = array() );

// Parse the mask replacements of a given page
$ this->_parseReplacementsTemplate( $options = array() );

// Parse the url mask of a given page and return the processed url
$ this->_parseUrl( $options = array() );

// Parse the mask replacements, changing from to-be replaced mask with new masks/values
$ this->_parseMaskReplacements( $str );

class PagerLayoutWithArrows extends Doctrine_Pager_Layout
{
    public function display( $options = array(), $return = false )
    {
        $pager = $this->getPager();
        $str   = '';

        // First page
        $this->addMaskReplacement( 'page', '«', true );
        $options['page_number'] = $pager->getFirstPage();
        $str                   .= $this->processPage( $options );

        // Previous page
        $this->addMaskReplacement( 'page', '‹', true );
        $options['page_number'] = $pager->getPreviousPage();
        $str                   .= $this->processPage( $options );

        // Pages listing
        $this->removeMaskReplacement( 'page' );
        $str .= parent::display( $options, true );

        // Next page
        $this->addMaskReplacement( 'page', '›', true );
        $options['page_number'] = $pager->getNextPage();
        $str                   .= $this->processPage( $options );

        // Last page
        $this->addMaskReplacement( 'page', '»', true );
        $options['page_number'] = $pager->getLastPage();
        $str                   .= $this->processPage( $options );

        // Possible wish to return value instead of print it on screen
        if ( $return )
        {
            return $str;
        }

        echo $str;
    }
}

class sfDoctrinePagerLayout extends Doctrine_Pager_Layout
{
    public function __construct( $pager, $pagerRange, $urlMask )
    {
        sfLoader::loadHelpers( array( 'Url', 'Tag' ) );
        parent::__construct( $pager, $pagerRange, $urlMask );
    }

    protected function _parseTemplate( $options = array() )
    {
        $str = parent::_parseTemplate( $options );

        return preg_replace(
            '/\{link_to\}(.*?)\{\/link_to\}/', link_to( '$1', $this->_parseUrl( $options ) ), $str
        );
}

$ pagerLayout = new sfDoctrinePagerLayout(
    $pager,
    new Doctrine_Pager_Range_Sliding(
        array(
            'chunk' => 5
        )
    ),
    '@hostHistoryList?page={%page_number}'
);

$ pagerLayout->setTemplate( '[{link_to}{%page}{/link_to}]' );

// Turn debug on/off and check for whether it is on/off
Doctrine_Core::debug( true );

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

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

// Set the path to your Doctrine libraries if it is some non-default location
Doctrine_Core::setPath( '/path/to/doctrine/libs' );

// 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_Core::loadModels( '/path/to/models', Doctrine_Core::MODEL_LOADING_CONSERVATIVE );
// or Doctrine_Core::MODEL_LOADING_AGGRESSIVE
print_r( $models );

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

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

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

// Generate YAML schema from an existing database
Doctrine_Core::generateYamlFromDb( '/path/to/dump/schema.yml', array( 'connection_name' ), $options );

// Generate your models from an existing database
Doctrine_Core::generateModelsFromDb( '/path/to/generate/models', array( 'connection_name' ), $options );

// Array of options and the default values
$ options = array(
    'packagesPrefix'       => 'Package',
    'packagesPath'         => '',
    'packagesFolderName'   => 'packages',
    'suffix'               => '.php',
    'generateBaseClasses'  => true,
    'baseClassesPrefix'    => 'Base',
    'baseClassesDirectory' => 'generated',
    'baseClassName'        => 'Doctrine_Record'
);

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

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

// Create all your tables from an existing set of models
// Will generate sql for all loaded models if no directory is given
Doctrine_Core::createTablesFromModels( '/path/to/models' );

// Generate string of sql commands from an existing set of models
// Will generate sql for all loaded models if no directory is given
Doctrine_Core::generateSqlFromModels( '/path/to/models' );

// Generate array of sql statements to create the array of passed models
Doctrine_Core::generateSqlFromArray( array( 'User', 'Phonenumber' ) );

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

// Create all databases for connections.
// Array of connection names is optional
Doctrine_Core::createDatabases( array( 'connection_name' ) );

// Drop all databases for connections
// Array of connection names is optional
Doctrine_Core::dropDatabases( array( 'connection_name' ) );

// 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_Core::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_Core::loadData( '/path/to/fixture/files', true );

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

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

// Generate all migration classes for an existing database
Doctrine_Core::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_Core::generateMigrationsFromModels( '/path/to/migrations', '/path/to/models' );

// Get Doctrine_Table instance for a model
$ userTable = Doctrine_Core::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_Core::compile( '/path/to/write/compiled/doctrine', $drivers );

// Dump doctrine objects for debugging
$ conn = Doctrine_Manager::connection();
Doctrine_Core::dump( $conn );

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

$ ./doctrine
Doctrine Command Line Interface
./doctrine build-all
./doctrine build-all-load
./doctrine build-all-reload
./doctrine compile
./doctrine create-db
./doctrine create-tables
./doctrine dql
./doctrine drop-db
./doctrine dump-data
./doctrine generate-migration
./doctrine generate-migrations-db
./doctrine generate-migrations-models
./doctrine generate-models-db
./doctrine generate-models-yaml
./doctrine generate-sql
./doctrine generate-yaml-db
./doctrine generate-yaml-models
./doctrine load-data
./doctrine migrate
./doctrine rebuild-db

$ task = new Doctrine_Task_GenerateModelsFromYaml();
$ args = array(
    'yaml_schema_path' => '/path/to/schema',
    'models_path'      => '/path/to/models'
);

$ task->setArguments( $args );

try
{
    if ( $task->validate() )
    {
        $task->execute();
    }
}
catch ( Exception $e )
{
    throw new Doctrine_Exception( $e->getMessage() );
}

#!/usr/bin/env php
[php]

chdir( dirname( __FILE__ ) );
include( 'doctrine.php' );

// Include your Doctrine configuration/setup here, your connections, models, etc.

// Configure Doctrine Cli
// Normally these are arguments to the cli tasks but if they are set here the arguments will be auto-filled and are not required for you to enter them.

$ config = array(
    'data_fixtures_path' => '/path/to/data/fixtures',
    'models_path'        => '/path/to/models',
    'migrations_path'    => '/path/to/migrations',
    'sql_path'           => '/path/to/data/sql',
    'yaml_schema_path'   => '/path/to/schema'
);

$ cli = new Doctrine_Cli( $config );
$ cli->run( $_SERVER['argv'] );

./doctrine generate-models-yaml
./doctrine create-tables

svn co http://www.doctrine-project.org/svn/branches/0.11 doctrine
cd doctrine/tools/sandbox
chmod 0777 doctrine

./doctrine