lib/AkInstaller.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   3
   4 // +----------------------------------------------------------------------+
   5 // | Akelos Framework - http://www.akelos.org                             |
   6 // +----------------------------------------------------------------------+
   7 // | Copyright (c) 2002-2006, Akelos Media, S.L.  & Bermi Ferrer Martinez |
   8 // | Released under the GNU Lesser General Public License, see LICENSE.txt|
   9 // +----------------------------------------------------------------------+
  10
  11 /**
  12  * @package ActiveSupport
  13  * @subpackage Installer
  14  * @author Bermi Ferrer <bermi a.t akelos c.om>
  15  * @copyright Copyright (c) 2002-2006, Akelos Media, S.L. http://www.akelos.org
  16  * @license GNU Lesser General Public License <http://www.gnu.org/copyleft/lesser.html>
  17  */
  18
  19 require_once(AK_LIB_DIR.DS.'Ak.php');
  20 require_once(AK_LIB_DIR.DS.'AkActiveRecord.php');
  21 file_exists(AK_APP_DIR.DS.'shared_model.php') ? require_once(AK_APP_DIR.DS.'shared_model.php') : null;
  22 defined('AK_APP_INSTALLERS_DIR') ? null : define('AK_APP_INSTALLERS_DIR', AK_APP_DIR.DS.'installers');
  23
  24 // Install scripts might use more RAM than normal requests.
  25 @ini_set('memory_limit', -1);
  26
  27 class AkInstaller
  28 {
  29     var $db;
  30     var $data_dictionary;
  31     var $debug = false;
  32     var $available_tables = array();
  33     var $vervose = true;
  34     var $module;
  35     var $warn_if_same_version = true;
  36
  37     function AkInstaller($db_connection = null)
  38     {
  39         if(empty($db_connection)){
  40             $this->db =& Ak::db();
  41         }else {
  42             $this->db =& $db_connection;
  43         }
  44
  45         $this->available_tables = $this->getAvailableTables();
  46
  47         $this->db->debug =& $this->debug;
  48
  49         $this->data_dictionary = NewDataDictionary($this->db);
  50     }
  51
  52     function install($version = null, $options = array())
  53     {
  54         $version = (is_null($version)) ? max($this->getAvailableVersions()) : $version;
  55         return $this->_upgradeOrDowngrade('up',  $version , $options);
  56     }
  57
  58     function up($version = null, $options = array())
  59     {
  60         return $this->_upgradeOrDowngrade('up', $version, $options);
  61     }
  62
  63
  64     function uninstall($version = null, $options = array())
  65     {
  66         $version = (is_null($version)) ? 0 : $version;
  67         return $this->_upgradeOrDowngrade('down', $version, $options);
  68     }
  69
  70     function down($version = null, $options = array())
  71     {
  72         return $this->_upgradeOrDowngrade('down', $version, $options);
  73     }
  74
  75
  76     function _upgradeOrDowngrade($action, $version = null, $options = array())
  77     {
  78         if(in_array('quiet',$options) && AK_ENVIRONMENT == 'development'){
  79             $this->vervose = false;
  80         }elseif(!empty($this->vervose) && AK_ENVIRONMENT == 'development'){
  81             $this->db->debug = true;
  82         }
  83
  84         $current_version = $this->getInstalledVersion($options);
  85         $available_versions = $this->getAvailableVersions();
  86
  87         $action = stristr($action,'down') ? 'down' : 'up';
  88
  89         if($action == 'up'){
  90             $newest_version = max($available_versions);
  91             $version = isset($version[0]) && is_numeric($version[0]) ? $version[0] : $newest_version;
  92             $versions = range($current_version+1,$version);
  93
  94             if($current_version > $version){
  95                 echo Ak::t("You can't upgrade to version %version, when you are currently on version %current_version", array('%version'=>$version,'%current_version'=>$current_version));
  96                 return false;
  97             }
  98         }else{
  99             $version = !empty($version[0]) && is_numeric($version[0]) ? $version[0] : 0;
 100             $versions = range($current_version, empty($version) ? 1 : $version+1);
 101
 102             if($current_version == 0){
 103                 return true;
 104             }elseif($current_version < $version){
 105                 echo Ak::t("You can't downgrade to version %version, when you just have installed version %current_version", array('%version'=>$version,'%current_version'=>$current_version));
 106                 return false;
 107             }
 108         }
 109
 110         if($this->warn_if_same_version && $current_version == $version){
 111             echo Ak::t("Can't go $action to version %version, you're already on version %version", array('%version'=>$version));
 112             return false;
 113         }
 114
 115         if(AK_CLI && !empty($this->vervose) && AK_ENVIRONMENT == 'development'){
 116             echo Ak::t(ucfirst($action).'grading');
 117         }
 118
 119         if(!empty($versions) && is_array($versions)){
 120             foreach ($versions as $version){
 121                 if(!$this->_runInstallerMethod($action, $version, $options)){
 122                     return false;
 123                 }
 124             }
 125         }else{
 126             return false;
 127         }
 128
 129         return true;
 130     }
 131
 132
 133     function installVersion($version, $options = array())
 134     {
 135         return $this->_runInstallerMethod('up', $version, $options);
 136     }
 137
 138     function uninstallVersion($version, $options = array())
 139     {
 140         return $this->_runInstallerMethod('down', $version, $options);
 141     }
 142
 143     /**
 144      * Runs a a dow_1, up_3 method and wraps it into a transaction.
 145      */
 146     function _runInstallerMethod($method_prefix, $version, $options = array(), $version_number = null)
 147     {
 148         $method_name = $method_prefix.'_'.$version;
 149         if(!method_exists($this, $method_name)){
 150             return false;
 151         }
 152
 153         $version_number = empty($version_number) ? ($method_prefix=='down' ? $version-1 : $version) : $version_number;
 154
 155         $this->transactionStart();
 156         if($this->$method_name($options) === false){
 157             $this->transactionFail();
 158         }
 159         $success = !$this->transactionHasFailed();
 160         $this->transactionComplete();
 161         if($success){
 162             $this->setInstalledVersion($version_number, $options);
 163         }
 164         return $success;
 165     }
 166
 167     function getInstallerName()
 168     {
 169         return str_replace('installer','',strtolower(get_class($this)));
 170     }
 171
 172
 173     function _versionPath($options = array())
 174     {
 175         $mode = empty($options['mode']) ? AK_ENVIRONMENT : $options['mode'];
 176         return AK_APP_INSTALLERS_DIR.DS.(empty($this->module)?'':$this->module.DS).'versions'.DS.$mode.'_'.$this->getInstallerName().'_version.txt';
 177     }
 178
 179
 180     function getInstalledVersion($options = array())
 181     {
 182         $version_file = $this->_versionPath($options);
 183
 184         if(!is_file($version_file)){
 185             $this->setInstalledVersion(0, $options);
 186         }
 187         return Ak::file_get_contents($this->_versionPath($options));
 188     }
 189
 190
 191     function setInstalledVersion($version, $options = array())
 192     {
 193         return Ak::file_put_contents($this->_versionPath($options), $version);
 194     }
 195
 196
 197     function getAvailableVersions()
 198     {
 199         $versions = array();
 200         foreach(get_class_methods($this) as $method_name){
 201             if(preg_match('/^up_([0-9]*)$/',$method_name, $match)){
 202                 $versions[] = $match[1];
 203             }
 204         }
 205         sort($versions);
 206         return $versions;
 207     }
 208
 209
 210     function modifyTable($table_name, $column_options = null, $table_options = array())
 211     {
 212         return $this->_createOrModifyTable($table_name, $column_options, $table_options);
 213     }
 214
 215     /**
 216      * Adds a new column to the table called $table_name
 217      */
 218     function addColumn($table_name, $column_details)
 219     {
 220         $column_details = $this->_getColumnsAsAdodbDataDictionaryString($column_details);
 221         return $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->AddColumnSQL($table_name, $column_details));
 222     }
 223
 224     function changeColumn($table_name, $column_details)
 225     {
 226         $column_details = $this->_getColumnsAsAdodbDataDictionaryString($column_details);
 227         return $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->AlterColumnSQL($table_name, $column_details));
 228     }
 229
 230     function removeColumn($table_name, $column_name)
 231     {
 232         return $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->DropColumnSQL($table_name, $column_name));
 233     }
 234
 235     function renameColumn($table_name, $old_column_name, $new_column_name)
 236     {
 237         if(!strstr($this->db->databaseType,'mysql')){
 238             trigger_error(Ak::t('Column renaming is only supported when using MySQL databases'), E_USER_ERROR);
 239         }
 240         return $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->RenameColumnSQL($table_name, $old_column_name, $new_column_name));
 241     }
 242
 243
 244     function createTable($table_name, $column_options = null, $table_options = array())
 245     {
 246         static $created_tables = array();
 247
 248         if(in_array($table_name, $created_tables)){
 249             //return false;
 250         }
 251         if($this->tableExists($table_name)){
 252             trigger_error(Ak::t('Table %table_name already exists on the database', array('%table_name'=>$table_name)), E_USER_NOTICE);
 253             return false;
 254         }
 255         $created_tables[] = $table_name;
 256         return $this->_createOrModifyTable($table_name, $column_options, $table_options);
 257     }
 258
 259     function _createOrModifyTable($table_name, $column_options = null, $table_options = array())
 260     {
 261         if(empty($column_options) && $this->_loadDbDesignerDbSchema()){
 262             $column_options = $this->db_designer_schema[$table_name];
 263         }elseif(empty($column_options)){
 264             trigger_error(Ak::t('You must supply details for the table you are creating.'), E_USER_ERROR);
 265             return false;
 266         }
 267
 268         $column_options = is_string($column_options) ? array('columns'=>$column_options) : $column_options;
 269
 270         $default_column_options = array(
 271         'sequence_table' => false
 272         );
 273         $column_options = array_merge($default_column_options, $column_options);
 274
 275         $default_table_options = array(
 276         'mysql' => 'TYPE=InnoDB',
 277         //'REPLACE'
 278         );
 279         $table_options = array_merge($default_table_options, $table_options);
 280
 281         $column_string = $this->_getColumnsAsAdodbDataDictionaryString($column_options['columns']);
 282
 283         $result = $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->ChangeTableSQL($table_name, str_replace(array(' UNIQUE', ' INDEX', ' FULLTEXT', ' HASH'), '', $column_string), $table_options));
 284
 285         if($result){
 286             $this->available_tables[] = $table_name;
 287         }
 288
 289         $columns_to_index = $this->_getColumnsToIndex($column_string);
 290
 291         foreach ($columns_to_index as $column_to_index => $index_type){
 292             $this->addIndex($table_name, $column_to_index.($index_type != 'INDEX' ? ' '.$index_type : ''));
 293         }
 294
 295         if(isset($column_options['index_columns'])){
 296             $this->addIndex($table_name, $column_options['index_columns']);
 297
 298         }
 299         if($column_options['sequence_table'] || $this->_requiresSequenceTable($column_string)){
 300             $this->createSequence($table_name);
 301         }
 302
 303         return $result;
 304     }
 305
 306     function dropTable($table_name, $options = array())
 307     {
 308         $result = $this->tableExists($table_name) ? $this->db->Execute('DROP TABLE '.$table_name) : true;
 309         if($result){
 310             unset($this->available_tables[array_search($table_name, $this->available_tables)]);
 311             if(!empty($options['sequence'])){
 312                 $this->dropSequence($table_name);
 313             }
 314         }
 315     }
 316
 317     function dropTables()
 318     {
 319         $args = func_get_args();
 320         if(!empty($args)){
 321             $num_args = count($args);
 322             $options = $num_args > 1 && is_array($args[$num_args-1]) ? array_shift($args) : array();
 323             $tables = count($args) > 1 ? $args : (is_array($args[0]) ? $args[0] : Ak::toArray($args[0]));
 324             foreach ($tables as $table){
 325                 $this->dropTable($table, $options);
 326             }
 327         }
 328     }
 329
 330     function addIndex($table_name, $columns, $index_name = '')
 331     {
 332         $index_name = ($index_name == '') ? 'idx_'.$table_name.'_'.$columns : $index_name;
 333         $index_options = array();
 334         if(preg_match('/(UNIQUE|FULLTEXT|HASH)/',$columns,$match)){
 335             $columns = trim(str_replace($match[1],'',$columns),' ');
 336             $index_options[] = $match[1];
 337         }
 338         return $this->tableExists($table_name) ? $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->CreateIndexSQL($index_name, $table_name, $columns, $index_options)) : false;
 339     }
 340
 341     function removeIndex($table_name, $columns_or_index_name)
 342     {
 343         if(!$this->tableExists($table_name)) return false;
 344         $available_indexes =& $this->db->MetaIndexes($table_name);
 345         $index_name = isset($available_indexes[$columns_or_index_name]) ? $columns_or_index_name : 'idx_'.$table_name.'_'.$columns_or_index_name;
 346         if(!isset($available_indexes[$index_name])){
 347             trigger_error(Ak::t('Index %index_name does not exist.', array('%index_name'=>$index_name)), E_USER_NOTICE);
 348             return false;
 349         }
 350         return $this->data_dictionary->ExecuteSQLArray($this->data_dictionary->DropIndexSQL($index_name, $table_name));
 351     }
 352
 353     function dropIndex($table_name, $columns_or_index_name)
 354     {
 355         return $this->removeIndex($table_name,$columns_or_index_name);
 356     }
 357
 358     function createSequence($table_name)
 359     {
 360         $result = $this->tableExists('seq_'.$table_name) ? false : $this->db->CreateSequence('seq_'.$table_name);
 361         $this->available_tables[] = 'seq_'.$table_name;
 362         return $result;
 363     }
 364
 365     function dropSequence($table_name)
 366     {
 367         $result = $this->tableExists('seq_'.$table_name) ? $this->db->DropSequence('seq_'.$table_name) : true;
 368         if($result){
 369             unset($this->available_tables[array_search('seq_'.$table_name, $this->available_tables)]);
 370
 371         }
 372         return $result;
 373     }
 374
 375     function getAvailableTables()
 376     {
 377         if(empty($this->available_tables)){
 378             $this->available_tables = array_diff((array)$this->db->MetaTables(), array(''));
 379         }
 380         return $this->available_tables;
 381     }
 382
 383     function tableExists($table_name)
 384     {
 385         return in_array($table_name,$this->getAvailableTables());
 386     }
 387
 388     function _getColumnsAsAdodbDataDictionaryString($columns)
 389     {
 390         $columns = $this->_setColumnDefaults($columns);
 391         $this->_ensureColumnNameCompatibility($columns);
 392         $equivalences = array(
 393         '/ ((limit|max|length) ?= ?)([0-9]+)([ \n\r,]+)/'=> ' (\3) ',
 394         '/([ \n\r,]+)default([ =]+)([^\'^,^\n]+)/i'=> ' DEFAULT \'\3\'',
 395         '/([ \n\r,]+)(integer|int)([( \n\r,]*)/'=> '\1 I \3',
 396         '/([ \n\r,]+)float([( \n\r,]+)/'=> '\1 F \2',
 397         '/([ \n\r,]+)datetime([( \n\r,]*)/'=> '\1 T \2',
 398         '/([ \n\r,]+)date([( \n\r,]*)/'=> '\1 D \2',
 399         '/([ \n\r,]+)timestamp([( \n\r,]*)/'=> '\1 T \2',
 400         '/([ \n\r,]+)time([( \n\r,]*)/'=> '\1 T \2',
 401         '/([ \n\r,]+)text([( \n\r,]*)/'=> '\1 XL \2',
 402         '/([ \n\r,]+)string([( \n\r,]*)/'=> '\1 C \2',
 403         '/([ \n\r,]+)binary([( \n\r,]*)/'=> '\1 B \2',
 404         '/([ \n\r,]+)boolean([( \n\r,]*)/'=> '\1 L(1) \2',
 405         '/ NOT( |_)?NULL/i'=> ' NOTNULL',
 406         '/ AUTO( |_)?INCREMENT/i'=> ' AUTO ',
 407         '/ +/'=> ' ',
 408         '/ ([\(,]+)/'=> '\1',
 409         '/ INDEX| IDX/i'=> ' INDEX ',
 410         '/ UNIQUE/i'=> ' UNIQUE ',
 411         '/ HASH/i'=> ' HASH ',
 412         '/ FULL_?TEXT/i'=> ' FULLTEXT ',
 413         '/ ((PRIMARY( |_)?)?KEY|pk)/i'=> ' KEY',
 414         );
 415
 416         return trim(preg_replace(array_keys($equivalences),array_values($equivalences), ' '.$columns.' '), ' ');
 417     }
 418
 419     function _setColumnDefaults($columns)
 420     {
 421         $columns = str_replace("\t",' ', $columns);
 422         if(is_string($columns)){
 423             if(strstr($columns,"\n")){
 424                 $columns = explode("\n",$columns);
 425             }elseif(strstr($columns,',')){
 426                 $columns = explode(',',$columns);
 427             }
 428         }
 429         foreach ((array)$columns as $column){
 430             $column = trim($column, "\n\r, ");
 431             if(!empty($column)){
 432                 $single_columns[$column] = $this->_setColumnDefault($column);
 433             }
 434         }
 435         return join(",\n", $single_columns);
 436     }
 437
 438     function _setColumnDefault($column)
 439     {
 440         return $this->_needsDefaultAttributes($column) ? $this->_setDefaultAttributes($column) : $column;
 441     }
 442
 443     function _needsDefaultAttributes($column)
 444     {
 445         return preg_match('/^(([A-Z0-9_\(\)]+)|(.+ string[^\(.]*)|(\*.*))$/i',$column);
 446     }
 447
 448     function _setDefaultAttributes($column)
 449     {
 450         $rules = $this->getDefaultColumnAttributesRules();
 451         foreach ($rules as $regex=>$replacement){
 452             if(is_string($replacement)){
 453                 $column = preg_replace($regex,$replacement,$column);
 454             }elseif(preg_match($regex,$column,$match)){
 455                 $column = call_user_func_array($replacement,$match);
 456             }
 457         }
 458         return $column;
 459     }
 460
 461     /**
 462      * Returns a key => value pair of regular expressions that will trigger methods
 463      * to cast database columns to their respective default values or a replacement expression.
 464      */
 465     function getDefaultColumnAttributesRules()
 466     {
 467         return array(
 468         '/^\*(.*)$/i' => array(&$this,'_castToMultilingualColumn'),
 469         '/^(description|content|body)$/i' => '\1 text',
 470         '/^(id)$/i' => 'id integer not null auto_increment primary_key',
 471         '/^(.+)_(id|by)$/i' => '\1_\2 integer index',
 472         '/^(position)$/i' => '\1 integer index',
 473         '/^(.+_at)$/i' => '\1 datetime',
 474         '/^(.+_on)$/i' => '\1 date',
 475         '/^(is_|has_|do_|does_|are_)([A-Z0-9_]+)$/i' => '\1\2 boolean not null default \'0\' index', //
 476         '/^([A-Z0-9_]+) *(\([0-9]+\))?$/i' => '\1 string\2', // Everything else will default to string
 477         '/^((.+ )string([^\(.]*))$/i' => '\2string(255)\3', // If we don't set the string lenght it will fail, so if not present will set it to 255
 478         );
 479     }
 480
 481     function _castToMultilingualColumn($found, $column)
 482     {
 483         $columns = array();
 484         foreach (Ak::langs() as $lang){
 485             $columns[] = $lang.'_'.ltrim($column);
 486         }
 487         return $this->_setColumnDefaults($columns);
 488     }
 489
 490     function _getColumnsToIndex($column_string)
 491     {
 492         $columns_to_index = array();
 493         foreach (explode(',',$column_string.',') as $column){
 494             if(preg_match('/([A-Za-z0-9_]+) (.*) (INDEX|UNIQUE|FULLTEXT|HASH) ?(.*)$/i',$column,$match)){
 495                 $columns_to_index[$match[1]] = $match[3];
 496             }
 497         }
 498         return $columns_to_index;
 499     }
 500
 501     function _getUniqueValueColumns($column_string)
 502     {
 503         $unique_columns = array();
 504         foreach (explode(',',$column_string.',') as $column){
 505             if(preg_match('/([A-Za-z0-9_]+) (.*) UNIQUE ?(.*)$/',$column,$match)){
 506                 $unique_columns[] = $match[1];
 507             }
 508         }
 509         return $unique_columns;
 510     }
 511
 512     function _requiresSequenceTable($column_string)
 513     {
 514         if(preg_match('/mysql|postgres/', $this->db->databaseType)){
 515             return false;
 516         }
 517         foreach (explode(',',$column_string.',') as $column){
 518             if(preg_match('/([A-Za-z0-9_]+) (.*) AUTO (.*)$/',$column)){
 519                 return true;
 520             }
 521             if(preg_match('/^id /',$column)){
 522                 return true;
 523             }
 524         }
 525         return false;
 526     }
 527
 528
 529     /**
 530     * Transaction support for database operations
 531     *
 532     * Transactions are enabled automatically for Intaller objects, But you can nest transactions within models.
 533     * This transactions are nested, and only the othermost will be executed
 534     *
 535     *   $UserInstalller->transactionStart();
 536     *   $UserInstalller->addTable('id, name');
 537     *
 538     *    if(!isCompatible()){
 539     *       $User->transactionFail();
 540     *    }
 541     *
 542     *   $User->transactionComplete();
 543     */
 544     function transactionStart()
 545     {
 546         return $this->db->StartTrans();
 547     }
 548
 549     function transactionComplete()
 550     {
 551         return $this->db->CompleteTrans();
 552     }
 553
 554     function transactionFail()
 555     {
 556         return $this->db->FailTrans();
 557     }
 558
 559     function transactionHasFailed()
 560     {
 561         return $this->db->HasFailedTrans();
 562     }
 563
 564
 565     function _loadDbDesignerDbSchema()
 566     {
 567         if($path = $this->_getDbDesignerFilePath()){
 568             $this->db_designer_schema = Ak::convert('DBDesigner','AkelosDatabaseDesign', Ak::file_get_contents($path));
 569             return !empty($this->db_designer_schema);
 570         }
 571         return false;
 572     }
 573
 574     function _getDbDesignerFilePath()
 575     {
 576         $path = AK_APP_INSTALLERS_DIR.DS.$this->getInstallerName().'.xml';
 577         return file_exists($path) ? $path : false;
 578     }
 579
 580     function _ensureColumnNameCompatibility($columns)
 581     {
 582         $columns = explode(',',$columns.',');
 583         foreach ($columns as $column){
 584             $column = trim($column);
 585             $column = substr($column, 0, strpos($column.' ',' '));
 586             $this->_canUseColumn($column);
 587         }
 588     }
 589
 590     function _canUseColumn($column_name)
 591     {
 592         $invalid_columns = $this->_getInvalidColumnNames();
 593         if(in_array($column_name, $invalid_columns)){
 594
 595             $method_name_part = AkInflector::camelize($column_name);
 596             require_once(AK_LIB_DIR.DS.'AkActiveRecord.php');
 597             $method_name = (method_exists(new AkActiveRecord(), 'set'.$method_name_part)?'set':'get').$method_name_part;
 598
 599             trigger_error(Ak::t('A method named %method_name exists in the AkActiveRecord class'.
 600             ' which will cause a recusion problem if you use the column %column_name in your database. '.
 601             'You can disable automatic %type by setting the constant %constant to false '.
 602             'in your configuration file.', array(
 603             '%method_name'=> $method_name,
 604             '%column_name' => $column_name,
 605             '%type' => Ak::t($method_name[0] == 's' ? 'setters' : 'getters'),
 606             '%constant' => Ak::t($method_name[0] == 's' ? 'AK_ACTIVE_RECORD_ENABLE_CALLBACK_SETTERS' : 'AK_ACTIVE_RECORD_ENABLE_CALLBACK_GETTERS'),
 607             ''
 608             )), E_USER_ERROR);
 609         }
 610     }
 611
 612     function _getInvalidColumnNames()
 613     {
 614         return defined('AK_INVALID_ACTIVE_RECORD_COLUMNS') ? explode(',',AK_INVALID_ACTIVE_RECORD_COLUMNS) : array('sanitized_conditions_array','conditions','inheritance_column','inheritance_column',
 615         'subclasses','attribute','attributes','attribute','attributes','accessible_attributes','protected_attributes',
 616         'serialized_attributes','available_attributes','attribute_caption','primary_key','column_names','content_columns',
 617         'attribute_names','combined_subattributes','available_combined_attributes','connection','connection','primary_key',
 618         'table_name','table_name','only_available_atrributes','columns_for_atrributes','columns_with_regex_boundaries','columns',
 619         'column_settings','column_settings','akelos_data_type','class_for_database_table_mapping','display_field','display_field',
 620         'internationalized_columns','available_locales','current_locale','attribute_by_locale','attribute_locales',
 621         'attribute_by_locale','attribute_locales','attributes_before_type_cast','attribute_before_type_cast','serialize_attribute',
 622         'available_attributes_quoted','attributes_quoted','column_type','value_for_date_column','observable_state',
 623         'observable_state','observers','errors','base_errors','errors_on','full_error_messages','array_from_ak_string',
 624         'attribute_condition','association_handler','associated','associated_finder_sql_options','association_option',
 625         'association_option','association_id','associated_ids','associated_handler_name','associated_type','association_type',
 626         'collection_handler_name','model_name','model_name','parent_model_name','parent_model_name');
 627     }
 628
 629     function execute($sql)
 630     {
 631         return $this->db->Execute($sql);
 632     }
 633
 634
 635     function usage()
 636     {
 637         echo Ak::t("Description:
 638     Database migrations is a sort of SCM like subversion, but for database settings.
 639
 640     The migration command takes the name of an installer located on your
 641     /app/installers folder and runs one of the following commands:
 642
 643     - \"install\" + (options version number): Will update to the provided version
 644     number or to the latest one in no version is given.
 645
 646     - \"uninstall\" + (options version number): Will downgrade to the provided
 647     version number or to the lowest one in no version is given.
 648
 649     Current version number will be sorted at app/installers/installer_name_version.txt.
 650
 651 Example:
 652     >> migrate framework install
 653
 654     Will run the default database schema for the framework.
 655     This generates the tables for handling database driven sessions and cache.
 656
 657 ");
 658     }
 659
 660
 661 }
 662
 663
 664 ?>