]> CyberLeo.Net >> Repos - Github/sugarcrm.git/blob - include/database/MysqlManager.php
Release 6.5.10
[Github/sugarcrm.git] / include / database / MysqlManager.php
1 <?php
2 if(!defined('sugarEntry') || !sugarEntry) die('Not A Valid Entry Point');
3 /*********************************************************************************
4  * SugarCRM Community Edition is a customer relationship management program developed by
5  * SugarCRM, Inc. Copyright (C) 2004-2013 SugarCRM Inc.
6  * 
7  * This program is free software; you can redistribute it and/or modify it under
8  * the terms of the GNU Affero General Public License version 3 as published by the
9  * Free Software Foundation with the addition of the following permission added
10  * to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED WORK
11  * IN WHICH THE COPYRIGHT IS OWNED BY SUGARCRM, SUGARCRM DISCLAIMS THE WARRANTY
12  * OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
13  * 
14  * This program is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
16  * FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more
17  * details.
18  * 
19  * You should have received a copy of the GNU Affero General Public License along with
20  * this program; if not, see http://www.gnu.org/licenses or write to the Free
21  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22  * 02110-1301 USA.
23  * 
24  * You can contact SugarCRM, Inc. headquarters at 10050 North Wolfe Road,
25  * SW2-130, Cupertino, CA 95014, USA. or at email address contact@sugarcrm.com.
26  * 
27  * The interactive user interfaces in modified source and object code versions
28  * of this program must display Appropriate Legal Notices, as required under
29  * Section 5 of the GNU Affero General Public License version 3.
30  * 
31  * In accordance with Section 7(b) of the GNU Affero General Public License version 3,
32  * these Appropriate Legal Notices must retain the display of the "Powered by
33  * SugarCRM" logo. If the display of the logo is not reasonably feasible for
34  * technical reasons, the Appropriate Legal Notices must display the words
35  * "Powered by SugarCRM".
36  ********************************************************************************/
37
38 /*********************************************************************************
39
40 * Description: This file handles the Data base functionality for the application.
41 * It acts as the DB abstraction layer for the application. It depends on helper classes
42 * which generate the necessary SQL. This sql is then passed to PEAR DB classes.
43 * The helper class is chosen in DBManagerFactory, which is driven by 'db_type' in 'dbconfig' under config.php.
44 *
45 * All the functions in this class will work with any bean which implements the meta interface.
46 * The passed bean is passed to helper class which uses these functions to generate correct sql.
47 *
48 * The meta interface has the following functions:
49 * getTableName()                        Returns table name of the object.
50 * getFieldDefinitions()         Returns a collection of field definitions in order.
51 * getFieldDefintion(name)               Return field definition for the field.
52 * getFieldValue(name)           Returns the value of the field identified by name.
53 *                               If the field is not set, the function will return boolean FALSE.
54 * getPrimaryFieldDefinition()   Returns the field definition for primary key
55 *
56 * The field definition is an array with the following keys:
57 *
58 * name          This represents name of the field. This is a required field.
59 * type          This represents type of the field. This is a required field and valid values are:
60 *           �   int
61 *           �   long
62 *           �   varchar
63 *           �   text
64 *           �   date
65 *           �   datetime
66 *           �   double
67 *           �   float
68 *           �   uint
69 *           �   ulong
70 *           �   time
71 *           �   short
72 *           �   enum
73 * length    This is used only when the type is varchar and denotes the length of the string.
74 *           The max value is 255.
75 * enumvals  This is a list of valid values for an enum separated by "|".
76 *           It is used only if the type is �enum�;
77 * required  This field dictates whether it is a required value.
78 *           The default value is �FALSE�.
79 * isPrimary This field identifies the primary key of the table.
80 *           If none of the fields have this flag set to �TRUE�,
81 *           the first field definition is assume to be the primary key.
82 *           Default value for this field is �FALSE�.
83 * default   This field sets the default value for the field definition.
84 *
85 *
86 * Portions created by SugarCRM are Copyright (C) SugarCRM, Inc.
87 * All Rights Reserved.
88 * Contributor(s): ______________________________________..
89 ********************************************************************************/
90
91 /**
92  * MySQL manager implementation for mysql extension
93  */
94 class MysqlManager extends DBManager
95 {
96         /**
97          * @see DBManager::$dbType
98          */
99         public $dbType = 'mysql';
100         public $variant = 'mysql';
101         public $dbName = 'MySQL';
102         public $label = 'LBL_MYSQL';
103
104         protected $maxNameLengths = array(
105                 'table' => 64,
106                 'column' => 64,
107                 'index' => 64,
108                 'alias' => 256
109         );
110
111         protected $type_map = array(
112                         'int'      => 'int',
113                         'double'   => 'double',
114                         'float'    => 'float',
115                         'uint'     => 'int unsigned',
116                         'ulong'    => 'bigint unsigned',
117                         'long'     => 'bigint',
118                         'short'    => 'smallint',
119                         'varchar'  => 'varchar',
120                         'text'     => 'text',
121                         'longtext' => 'longtext',
122                         'date'     => 'date',
123                         'enum'     => 'varchar',
124                         'relate'   => 'varchar',
125                         'multienum'=> 'text',
126                         'html'     => 'text',
127                         'longhtml' => 'longtext',
128                         'datetime' => 'datetime',
129                         'datetimecombo' => 'datetime',
130                         'time'     => 'time',
131                         'bool'     => 'bool',
132                         'tinyint'  => 'tinyint',
133                         'char'     => 'char',
134                         'blob'     => 'blob',
135                         'longblob' => 'longblob',
136                         'currency' => 'decimal(26,6)',
137                         'decimal'  => 'decimal',
138                         'decimal2' => 'decimal',
139                         'id'       => 'char(36)',
140                         'url'      => 'varchar',
141                         'encrypt'  => 'varchar',
142                         'file'     => 'varchar',
143                         'decimal_tpl' => 'decimal(%d, %d)',
144
145         );
146
147         protected $capabilities = array(
148                 "affected_rows" => true,
149                 "select_rows" => true,
150                 "inline_keys" => true,
151                 "create_user" => true,
152                 "fulltext" => true,
153             "collation" => true,
154             "create_db" => true,
155             "disable_keys" => true,
156         );
157
158         /**
159          * Parses and runs queries
160          *
161          * @param  string   $sql        SQL Statement to execute
162          * @param  bool     $dieOnError True if we want to call die if the query returns errors
163          * @param  string   $msg        Message to log if error occurs
164          * @param  bool     $suppress   Flag to suppress all error output unless in debug logging mode.
165          * @param  bool     $keepResult True if we want to push this result into the $lastResult array.
166          * @return resource result set
167          */
168         public function query($sql, $dieOnError = false, $msg = '', $suppress = false, $keepResult = false)
169         {
170                 if(is_array($sql)) {
171                         return $this->queryArray($sql, $dieOnError, $msg, $suppress);
172                 }
173
174                 parent::countQuery($sql);
175                 $GLOBALS['log']->info('Query:' . $sql);
176                 $this->checkConnection();
177                 $this->query_time = microtime(true);
178                 $this->lastsql = $sql;
179                 $result = $suppress?@mysql_query($sql, $this->database):mysql_query($sql, $this->database);
180
181                 $this->query_time = microtime(true) - $this->query_time;
182                 $GLOBALS['log']->info('Query Execution Time:'.$this->query_time);
183
184
185                 if($keepResult)
186                         $this->lastResult = $result;
187
188                 $this->checkError($msg.' Query Failed:' . $sql . '::', $dieOnError);
189                 return $result;
190         }
191
192     /**
193      * Returns the number of rows affected by the last query
194      * @param $result
195      * @return int
196      */
197         public function getAffectedRowCount($result)
198         {
199                 return mysql_affected_rows($this->getDatabase());
200         }
201
202         /**
203          * Returns the number of rows returned by the result
204          *
205          * This function can't be reliably implemented on most DB, do not use it.
206          * @abstract
207          * @deprecated
208          * @param  resource $result
209          * @return int
210          */
211         public function getRowCount($result)
212         {
213             return mysql_num_rows($result);
214         }
215
216         /**
217          * Disconnects from the database
218          *
219          * Also handles any cleanup needed
220          */
221         public function disconnect()
222         {
223                 $GLOBALS['log']->debug('Calling MySQL::disconnect()');
224                 if(!empty($this->database)){
225                         $this->freeResult();
226                         mysql_close($this->database);
227                         $this->database = null;
228                 }
229         }
230
231         /**
232          * @see DBManager::freeDbResult()
233          */
234         protected function freeDbResult($dbResult)
235         {
236                 if(!empty($dbResult))
237                         mysql_free_result($dbResult);
238         }
239
240
241         /**
242          * @abstract
243          * Check if query has LIMIT clause
244          * Relevant for now only for Mysql
245          * @param string $sql
246          * @return bool
247          */
248         protected function hasLimit($sql)
249         {
250             return stripos($sql, " limit ") !== false;
251         }
252
253         /**
254          * @see DBManager::limitQuery()
255          */
256         public function limitQuery($sql, $start, $count, $dieOnError = false, $msg = '', $execute = true)
257         {
258         $start = (int)$start;
259         $count = (int)$count;
260             if ($start < 0)
261                         $start = 0;
262                 $GLOBALS['log']->debug('Limit Query:' . $sql. ' Start: ' .$start . ' count: ' . $count);
263
264             $sql = "$sql LIMIT $start,$count";
265                 $this->lastsql = $sql;
266
267                 if(!empty($GLOBALS['sugar_config']['check_query'])){
268                         $this->checkQuery($sql);
269                 }
270                 if(!$execute) {
271                         return $sql;
272                 }
273
274                 return $this->query($sql, $dieOnError, $msg);
275         }
276
277
278         /**
279          * @see DBManager::checkQuery()
280          */
281         protected function checkQuery($sql)
282         {
283                 $result   = $this->query('EXPLAIN ' . $sql);
284                 $badQuery = array();
285                 while ($row = $this->fetchByAssoc($result)) {
286                         if (empty($row['table']))
287                                 continue;
288                         $badQuery[$row['table']] = '';
289                         if (strtoupper($row['type']) == 'ALL')
290                                 $badQuery[$row['table']]  .=  ' Full Table Scan;';
291                         if (empty($row['key']))
292                                 $badQuery[$row['table']] .= ' No Index Key Used;';
293                         if (!empty($row['Extra']) && substr_count($row['Extra'], 'Using filesort') > 0)
294                                 $badQuery[$row['table']] .= ' Using FileSort;';
295                         if (!empty($row['Extra']) && substr_count($row['Extra'], 'Using temporary') > 0)
296                                 $badQuery[$row['table']] .= ' Using Temporary Table;';
297                 }
298
299                 if ( empty($badQuery) )
300                         return true;
301
302                 foreach($badQuery as $table=>$data ){
303                         if(!empty($data)){
304                                 $warning = ' Table:' . $table . ' Data:' . $data;
305                                 if(!empty($GLOBALS['sugar_config']['check_query_log'])){
306                                         $GLOBALS['log']->fatal($sql);
307                                         $GLOBALS['log']->fatal('CHECK QUERY:' .$warning);
308                                 }
309                                 else{
310                                         $GLOBALS['log']->warn('CHECK QUERY:' .$warning);
311                                 }
312                         }
313                 }
314
315                 return false;
316         }
317
318         /**
319          * @see DBManager::get_columns()
320          */
321         public function get_columns($tablename)
322         {
323                 //find all unique indexes and primary keys.
324                 $result = $this->query("DESCRIBE $tablename");
325
326                 $columns = array();
327                 while (($row=$this->fetchByAssoc($result)) !=null) {
328                         $name = strtolower($row['Field']);
329                         $columns[$name]['name']=$name;
330                         $matches = array();
331                         preg_match_all('/(\w+)(?:\(([0-9]+,?[0-9]*)\)|)( unsigned)?/i', $row['Type'], $matches);
332                         $columns[$name]['type']=strtolower($matches[1][0]);
333                         if ( isset($matches[2][0]) && in_array(strtolower($matches[1][0]),array('varchar','char','varchar2','int','decimal','float')) )
334                                 $columns[$name]['len']=strtolower($matches[2][0]);
335                         if ( stristr($row['Extra'],'auto_increment') )
336                                 $columns[$name]['auto_increment'] = '1';
337                         if ($row['Null'] == 'NO' && !stristr($row['Key'],'PRI'))
338                                 $columns[$name]['required'] = 'true';
339                         if (!empty($row['Default']) )
340                                 $columns[$name]['default'] = $row['Default'];
341                 }
342                 return $columns;
343         }
344
345         /**
346          * @see DBManager::getFieldsArray()
347          */
348         public function getFieldsArray($result, $make_lower_case=false)
349         {
350                 $field_array = array();
351
352                 if(empty($result))
353                         return 0;
354
355                 $fields = mysql_num_fields($result);
356                 for ($i=0; $i < $fields; $i++) {
357                         $meta = mysql_fetch_field($result, $i);
358                         if (!$meta)
359                                 return array();
360
361                         if($make_lower_case == true)
362                                 $meta->name = strtolower($meta->name);
363
364                         $field_array[] = $meta->name;
365                 }
366
367                 return $field_array;
368         }
369
370         /**
371          * @see DBManager::fetchRow()
372          */
373         public function fetchRow($result)
374         {
375                 if (empty($result))     return false;
376
377                 return mysql_fetch_assoc($result);
378         }
379
380         /**
381          * @see DBManager::getTablesArray()
382          */
383         public function getTablesArray()
384         {
385                 $this->log->debug('Fetching table list');
386
387                 if ($this->getDatabase()) {
388                         $tables = array();
389                         $r = $this->query('SHOW TABLES');
390                         if (!empty($r)) {
391                                 while ($a = $this->fetchByAssoc($r)) {
392                                         $row = array_values($a);
393                                         $tables[]=$row[0];
394                                 }
395                                 return $tables;
396                         }
397                 }
398
399                 return false; // no database available
400         }
401
402         /**
403          * @see DBManager::version()
404          */
405         public function version()
406         {
407                 return $this->getOne("SELECT version() version");
408         }
409
410         /**
411          * @see DBManager::tableExists()
412          */
413         public function tableExists($tableName)
414         {
415                 $this->log->info("tableExists: $tableName");
416
417                 if ($this->getDatabase()) {
418                         $result = $this->query("SHOW TABLES LIKE ".$this->quoted($tableName));
419                         if(empty($result)) return false;
420                         $row = $this->fetchByAssoc($result);
421                         return !empty($row);
422                 }
423
424                 return false;
425         }
426
427         /**
428          * Get tables like expression
429          * @param $like string
430          * @return array
431          */
432         public function tablesLike($like)
433         {
434                 if ($this->getDatabase()) {
435                         $tables = array();
436                         $r = $this->query('SHOW TABLES LIKE '.$this->quoted($like));
437                         if (!empty($r)) {
438                                 while ($a = $this->fetchByAssoc($r)) {
439                                         $row = array_values($a);
440                                         $tables[]=$row[0];
441                                 }
442                                 return $tables;
443                         }
444                 }
445                 return false;
446         }
447
448         /**
449          * @see DBManager::quote()
450          */
451         public function quote($string)
452         {
453                 if(is_array($string)) {
454                         return $this->arrayQuote($string);
455                 }
456                 return mysql_real_escape_string($this->quoteInternal($string), $this->getDatabase());
457         }
458
459         /**
460          * @see DBManager::connect()
461          */
462         public function connect(array $configOptions = null, $dieOnError = false)
463         {
464                 global $sugar_config;
465
466                 if(is_null($configOptions))
467                         $configOptions = $sugar_config['dbconfig'];
468
469                 if ($this->getOption('persistent')) {
470                         $this->database = @mysql_pconnect(
471                                 $configOptions['db_host_name'],
472                                 $configOptions['db_user_name'],
473                                 $configOptions['db_password']
474                                 );
475                 }
476
477                 if (!$this->database) {
478                         $this->database = mysql_connect(
479                                         $configOptions['db_host_name'],
480                                         $configOptions['db_user_name'],
481                                         $configOptions['db_password']
482                                         );
483                         if(empty($this->database)) {
484                                 $GLOBALS['log']->fatal("Could not connect to server ".$configOptions['db_host_name']." as ".$configOptions['db_user_name'].":".mysql_error());
485                                 if($dieOnError) {
486                                         if(isset($GLOBALS['app_strings']['ERR_NO_DB'])) {
487                                                 sugar_die($GLOBALS['app_strings']['ERR_NO_DB']);
488                                         } else {
489                                                 sugar_die("Could not connect to the database. Please refer to sugarcrm.log for details.");
490                                         }
491                                 } else {
492                                         return false;
493                                 }
494                         }
495                         // Do not pass connection information because we have not connected yet
496                         if($this->database  && $this->getOption('persistent')){
497                                 $_SESSION['administrator_error'] = "<b>Severe Performance Degradation: Persistent Database Connections "
498                                         . "not working.  Please set \$sugar_config['dbconfigoption']['persistent'] to false "
499                                         . "in your config.php file</b>";
500                         }
501                 }
502                 if(!empty($configOptions['db_name']) && !@mysql_select_db($configOptions['db_name'])) {
503                         $GLOBALS['log']->fatal( "Unable to select database {$configOptions['db_name']}: " . mysql_error($this->database));
504                         if($dieOnError) {
505                                 sugar_die($GLOBALS['app_strings']['ERR_NO_DB']);
506                         } else {
507                                 return false;
508                         }
509                 }
510
511                 // cn: using direct calls to prevent this from spamming the Logs
512             mysql_query("SET CHARACTER SET utf8", $this->database);
513             $names = "SET NAMES 'utf8'";
514             $collation = $this->getOption('collation');
515             if(!empty($collation)) {
516                 $names .= " COLLATE '$collation'";
517                 }
518             mysql_query($names, $this->database);
519
520                 if(!$this->checkError('Could Not Connect:', $dieOnError))
521                         $GLOBALS['log']->info("connected to db");
522                 $this->connectOptions = $configOptions;
523
524                 $GLOBALS['log']->info("Connect:".$this->database);
525                 return true;
526         }
527
528         /**
529          * @see DBManager::repairTableParams()
530          *
531          * For MySQL, we can write the ALTER TABLE statement all in one line, which speeds things
532          * up quite a bit. So here, we'll parse the returned SQL into a single ALTER TABLE command.
533          */
534         public function repairTableParams($tablename, $fielddefs, $indices, $execute = true, $engine = null)
535         {
536                 $sql = parent::repairTableParams($tablename,$fielddefs,$indices,false,$engine);
537
538                 if ( $sql == '' )
539                         return '';
540
541                 if ( stristr($sql,'create table') )
542                 {
543                         if ($execute) {
544                                 $msg = "Error creating table: ".$tablename. ":";
545                                 $this->query($sql,true,$msg);
546                         }
547                         return $sql;
548                 }
549
550                 // first, parse out all the comments
551                 $match = array();
552                 preg_match_all('!/\*.*?\*/!is', $sql, $match);
553                 $commentBlocks = $match[0];
554                 $sql = preg_replace('!/\*.*?\*/!is','', $sql);
555
556                 // now, we should only have alter table statements
557                 // let's replace the 'alter table name' part with a comma
558                 $sql = preg_replace("!alter table $tablename!is",', ', $sql);
559
560                 // re-add it at the beginning
561                 $sql = substr_replace($sql,'',strpos($sql,','),1);
562                 $sql = str_replace(";","",$sql);
563                 $sql = str_replace("\n","",$sql);
564                 $sql = "ALTER TABLE $tablename $sql";
565
566                 if ( $execute )
567                         $this->query($sql,'Error with MySQL repair table');
568
569                 // and re-add the comments at the beginning
570                 $sql = implode("\n",$commentBlocks) . "\n". $sql . "\n";
571
572                 return $sql;
573         }
574
575         /**
576          * @see DBManager::convert()
577          */
578         public function convert($string, $type, array $additional_parameters = array())
579         {
580                 $all_parameters = $additional_parameters;
581                 if(is_array($string)) {
582                         $all_parameters = array_merge($string, $all_parameters);
583                 } elseif (!is_null($string)) {
584                         array_unshift($all_parameters, $string);
585                 }
586                 $all_strings = implode(',', $all_parameters);
587
588                 switch (strtolower($type)) {
589                         case 'today':
590                                 return "CURDATE()";
591                         case 'left':
592                                 return "LEFT($all_strings)";
593                         case 'date_format':
594                                 if(empty($additional_parameters)) {
595                                         return "DATE_FORMAT($string,'%Y-%m-%d')";
596                                 } else {
597                                         $format = $additional_parameters[0];
598                                         if($format[0] != "'") {
599                                                 $format = $this->quoted($format);
600                                         }
601                                         return "DATE_FORMAT($string,$format)";
602                                 }
603                         case 'ifnull':
604                                 if(empty($additional_parameters) && !strstr($all_strings, ",")) {
605                                         $all_strings .= ",''";
606                                 }
607                                 return "IFNULL($all_strings)";
608                         case 'concat':
609                                 return "CONCAT($all_strings)";
610                         case 'quarter':
611                                         return "QUARTER($string)";
612                         case "length":
613                                         return "LENGTH($string)";
614                         case 'month':
615                                         return "MONTH($string)";
616                         case 'add_date':
617                                         return "DATE_ADD($string, INTERVAL {$additional_parameters[0]} {$additional_parameters[1]})";
618                         case 'add_time':
619                                         return "DATE_ADD($string, INTERVAL + CONCAT({$additional_parameters[0]}, ':', {$additional_parameters[1]}) HOUR_MINUTE)";
620             case 'add_tz_offset' :
621                 $getUserUTCOffset = $GLOBALS['timedate']->getUserUTCOffset();
622                 $operation = $getUserUTCOffset < 0 ? '-' : '+';
623                 return $string . ' ' . $operation . ' INTERVAL ' . abs($getUserUTCOffset) . ' MINUTE';
624                 }
625
626                 return $string;
627         }
628
629         /**
630          * (non-PHPdoc)
631          * @see DBManager::fromConvert()
632          */
633         public function fromConvert($string, $type)
634         {
635                 return $string;
636         }
637
638         /**
639          * Returns the name of the engine to use or null if we are to use the default
640          *
641          * @param  object $bean SugarBean instance
642          * @return string
643          */
644         protected function getEngine($bean)
645         {
646                 global $dictionary;
647                 $engine = null;
648                 if (isset($dictionary[$bean->getObjectName()]['engine'])) {
649                         $engine = $dictionary[$bean->getObjectName()]['engine'];
650                 }
651                 return $engine;
652         }
653
654         /**
655          * Returns true if the engine given is enabled in the backend
656          *
657          * @param  string $engine
658          * @return bool
659          */
660         protected function isEngineEnabled($engine)
661         {
662                 if(!is_string($engine)) return false;
663
664                 $engine = strtoupper($engine);
665
666                 $r = $this->query("SHOW ENGINES");
667
668                 while ( $row = $this->fetchByAssoc($r) )
669                         if ( strtoupper($row['Engine']) == $engine )
670                                 return ($row['Support']=='YES' || $row['Support']=='DEFAULT');
671
672                 return false;
673         }
674
675         /**
676          * @see DBManager::createTableSQL()
677          */
678         public function createTableSQL(SugarBean $bean)
679         {
680                 $tablename = $bean->getTableName();
681                 $fieldDefs = $bean->getFieldDefinitions();
682                 $indices   = $bean->getIndices();
683                 $engine    = $this->getEngine($bean);
684                 return $this->createTableSQLParams($tablename, $fieldDefs, $indices, $engine);
685         }
686
687         /**
688          * Generates sql for create table statement for a bean.
689          *
690          * @param  string $tablename
691          * @param  array  $fieldDefs
692          * @param  array  $indices
693          * @param  string $engine optional, MySQL engine to use
694          * @return string SQL Create Table statement
695         */
696         public function createTableSQLParams($tablename, $fieldDefs, $indices, $engine = null)
697         {
698                 if ( empty($engine) && isset($fieldDefs['engine']))
699                         $engine = $fieldDefs['engine'];
700                 if ( !$this->isEngineEnabled($engine) )
701                         $engine = '';
702
703                 $columns = $this->columnSQLRep($fieldDefs, false, $tablename);
704                 if (empty($columns))
705                         return false;
706
707                 $keys = $this->keysSQL($indices);
708                 if (!empty($keys))
709                         $keys = ",$keys";
710
711                 // cn: bug 9873 - module tables do not get created in utf8 with assoc collation
712                 $collation = $this->getOption('collation');
713                 if(empty($collation)) {
714                     $collation = 'utf8_general_ci';
715                 }
716                 $sql = "CREATE TABLE $tablename ($columns $keys) CHARACTER SET utf8 COLLATE $collation";
717
718                 if (!empty($engine))
719                         $sql.= " ENGINE=$engine";
720
721                 return $sql;
722         }
723
724     /**
725      * Does this type represent text (i.e., non-varchar) value?
726      * @param string $type
727      */
728     public function isTextType($type)
729     {
730         $type = $this->getColumnType(strtolower($type));
731         return in_array($type, array('blob','text','longblob', 'longtext'));
732     }
733
734         /**
735          * @see DBManager::oneColumnSQLRep()
736          */
737         protected function oneColumnSQLRep($fieldDef, $ignoreRequired = false, $table = '', $return_as_array = false)
738         {
739                 // always return as array for post-processing
740                 $ref = parent::oneColumnSQLRep($fieldDef, $ignoreRequired, $table, true);
741
742                 if ( $ref['colType'] == 'int' && !empty($fieldDef['len']) ) {
743                         $ref['colType'] .= "(".$fieldDef['len'].")";
744                 }
745
746                 // bug 22338 - don't set a default value on text or blob fields
747                 if ( isset($ref['default']) &&
748             in_array($ref['colBaseType'], array('text', 'blob', 'longtext', 'longblob')))
749                             $ref['default'] = '';
750
751                 if ( $return_as_array )
752                         return $ref;
753                 else
754                         return "{$ref['name']} {$ref['colType']} {$ref['default']} {$ref['required']} {$ref['auto_increment']}";
755         }
756
757         /**
758          * @see DBManager::changeColumnSQL()
759          */
760         protected function changeColumnSQL($tablename, $fieldDefs, $action, $ignoreRequired = false)
761         {
762                 $columns = array();
763                 if ($this->isFieldArray($fieldDefs)){
764                         foreach ($fieldDefs as $def){
765                                 if ($action == 'drop')
766                                         $columns[] = $def['name'];
767                                 else
768                                         $columns[] = $this->oneColumnSQLRep($def, $ignoreRequired);
769                         }
770                 } else {
771                         if ($action == 'drop')
772                                 $columns[] = $fieldDefs['name'];
773                 else
774                         $columns[] = $this->oneColumnSQLRep($fieldDefs);
775                 }
776
777                 return "ALTER TABLE $tablename $action COLUMN ".implode(",$action column ", $columns);
778         }
779
780         /**
781          * Generates SQL for key specification inside CREATE TABLE statement
782          *
783          * The passes array is an array of field definitions or a field definition
784          * itself. The keys generated will be either primary, foreign, unique, index
785          * or none at all depending on the setting of the "key" parameter of a field definition
786          *
787          * @param  array  $indices
788          * @param  bool   $alter_table
789          * @param  string $alter_action
790          * @return string SQL Statement
791          */
792         protected function keysSQL($indices, $alter_table = false, $alter_action = '')
793         {
794         // check if the passed value is an array of fields.
795         // if not, convert it into an array
796         if (!$this->isFieldArray($indices))
797                 $indices[] = $indices;
798
799         $columns = array();
800         foreach ($indices as $index) {
801                 if(!empty($index['db']) && $index['db'] != $this->dbType)
802                         continue;
803                 if (isset($index['source']) && $index['source'] != 'db')
804                         continue;
805
806                 $type = $index['type'];
807                 $name = $index['name'];
808
809                 if (is_array($index['fields']))
810                         $fields = implode(", ", $index['fields']);
811                 else
812                         $fields = $index['fields'];
813
814                 switch ($type) {
815                 case 'unique':
816                         $columns[] = " UNIQUE $name ($fields)";
817                         break;
818                 case 'primary':
819                         $columns[] = " PRIMARY KEY ($fields)";
820                         break;
821                 case 'index':
822                 case 'foreign':
823                 case 'clustered':
824                 case 'alternate_key':
825                         /**
826                                 * @todo here it is assumed that the primary key of the foreign
827                                 * table will always be named 'id'. It must be noted though
828                                 * that this can easily be fixed by referring to db dictionary
829                                 * to find the correct primary field name
830                                 */
831                         if ( $alter_table )
832                                 $columns[] = " INDEX $name ($fields)";
833                         else
834                                 $columns[] = " KEY $name ($fields)";
835                         break;
836                 case 'fulltext':
837                         if ($this->full_text_indexing_installed())
838                                 $columns[] = " FULLTEXT ($fields)";
839                         else
840                                 $GLOBALS['log']->debug('MYISAM engine is not available/enabled, full-text indexes will be skipped. Skipping:',$name);
841                         break;
842                 }
843         }
844         $columns = implode(", $alter_action ", $columns);
845         if(!empty($alter_action)){
846                 $columns = $alter_action . ' '. $columns;
847         }
848         return $columns;
849         }
850
851         /**
852          * @see DBManager::setAutoIncrement()
853          */
854         protected function setAutoIncrement($table, $field_name)
855         {
856                 return "auto_increment";
857         }
858
859         /**
860          * Sets the next auto-increment value of a column to a specific value.
861          *
862          * @param  string $table tablename
863          * @param  string $field_name
864          */
865         public function setAutoIncrementStart($table, $field_name, $start_value)
866         {
867                 $start_value = (int)$start_value;
868                 return $this->query( "ALTER TABLE $table AUTO_INCREMENT = $start_value;");
869         }
870
871         /**
872          * Returns the next value for an auto increment
873          *
874          * @param  string $table tablename
875          * @param  string $field_name
876          * @return string
877          */
878         public function getAutoIncrement($table, $field_name)
879         {
880                 $result = $this->query("SHOW TABLE STATUS LIKE '$table'");
881                 $row = $this->fetchByAssoc($result);
882                 if (!empty($row['Auto_increment']))
883                         return $row['Auto_increment'];
884
885                 return "";
886         }
887
888         /**
889          * @see DBManager::get_indices()
890          */
891         public function get_indices($tablename)
892         {
893                 //find all unique indexes and primary keys.
894                 $result = $this->query("SHOW INDEX FROM $tablename");
895
896                 $indices = array();
897                 while (($row=$this->fetchByAssoc($result)) !=null) {
898                         $index_type='index';
899                         if ($row['Key_name'] =='PRIMARY') {
900                                 $index_type='primary';
901                         }
902                         elseif ( $row['Non_unique'] == '0' ) {
903                                 $index_type='unique';
904                         }
905                         $name = strtolower($row['Key_name']);
906                         $indices[$name]['name']=$name;
907                         $indices[$name]['type']=$index_type;
908                         $indices[$name]['fields'][]=strtolower($row['Column_name']);
909                 }
910                 return $indices;
911         }
912
913         /**
914          * @see DBManager::add_drop_constraint()
915          */
916         public function add_drop_constraint($table, $definition, $drop = false)
917         {
918                 $type         = $definition['type'];
919                 $fields       = implode(',',$definition['fields']);
920                 $name         = $definition['name'];
921                 $sql          = '';
922
923                 switch ($type){
924                 // generic indices
925                 case 'index':
926                 case 'alternate_key':
927                 case 'clustered':
928                         if ($drop)
929                                 $sql = "ALTER TABLE {$table} DROP INDEX {$name} ";
930                         else
931                                 $sql = "ALTER TABLE {$table} ADD INDEX {$name} ({$fields})";
932                         break;
933                 // constraints as indices
934                 case 'unique':
935                         if ($drop)
936                                 $sql = "ALTER TABLE {$table} DROP INDEX $name";
937                         else
938                                 $sql = "ALTER TABLE {$table} ADD CONSTRAINT UNIQUE {$name} ({$fields})";
939                         break;
940                 case 'primary':
941                         if ($drop)
942                                 $sql = "ALTER TABLE {$table} DROP PRIMARY KEY";
943                         else
944                                 $sql = "ALTER TABLE {$table} ADD CONSTRAINT PRIMARY KEY ({$fields})";
945                         break;
946                 case 'foreign':
947                         if ($drop)
948                                 $sql = "ALTER TABLE {$table} DROP FOREIGN KEY ({$fields})";
949                         else
950                                 $sql = "ALTER TABLE {$table} ADD CONSTRAINT FOREIGN KEY {$name} ({$fields}) REFERENCES {$definition['foreignTable']}({$definition['foreignField']})";
951                         break;
952                 }
953                 return $sql;
954         }
955
956         /**
957          * Runs a query and returns a single row
958          *
959          * @param  string   $sql        SQL Statement to execute
960          * @param  bool     $dieOnError True if we want to call die if the query returns errors
961          * @param  string   $msg        Message to log if error occurs
962          * @param  bool     $suppress   Message to log if error occurs
963          * @return array    single row from the query
964          */
965         public function fetchOne($sql, $dieOnError = false, $msg = '', $suppress = false)
966         {
967                 if(stripos($sql, ' LIMIT ') === false) {
968                         // little optimization to just fetch one row
969                         $sql .= " LIMIT 0,1";
970                 }
971                 return parent::fetchOne($sql, $dieOnError, $msg, $suppress);
972         }
973
974         /**
975          * @see DBManager::full_text_indexing_installed()
976          */
977         public function full_text_indexing_installed($dbname = null)
978         {
979                 return $this->isEngineEnabled('MyISAM');
980         }
981
982         /**
983          * @see DBManager::massageFieldDef()
984          */
985         public function massageFieldDef(&$fieldDef, $tablename)
986         {
987                 parent::massageFieldDef($fieldDef,$tablename);
988
989                 if ( isset($fieldDef['default']) &&
990                         ($fieldDef['dbType'] == 'text'
991                                 || $fieldDef['dbType'] == 'blob'
992                                 || $fieldDef['dbType'] == 'longtext'
993                                 || $fieldDef['dbType'] == 'longblob' ))
994                         unset($fieldDef['default']);
995                 if ($fieldDef['dbType'] == 'uint')
996                         $fieldDef['len'] = '10';
997                 if ($fieldDef['dbType'] == 'ulong')
998                         $fieldDef['len'] = '20';
999                 if ($fieldDef['dbType'] == 'bool')
1000                         $fieldDef['type'] = 'tinyint';
1001                 if ($fieldDef['dbType'] == 'bool' && empty($fieldDef['default']) )
1002                         $fieldDef['default'] = '0';
1003                 if (($fieldDef['dbType'] == 'varchar' || $fieldDef['dbType'] == 'enum') && empty($fieldDef['len']) )
1004                         $fieldDef['len'] = '255';
1005                 if ($fieldDef['dbType'] == 'uint')
1006                         $fieldDef['len'] = '10';
1007                 if ($fieldDef['dbType'] == 'int' && empty($fieldDef['len']) )
1008                         $fieldDef['len'] = '11';
1009
1010                 if($fieldDef['dbType'] == 'decimal') {
1011                         if(isset($fieldDef['len'])) {
1012                                 if(strstr($fieldDef['len'], ",") === false) {
1013                                         $fieldDef['len'] .= ",0";
1014                                 }
1015                         } else {
1016                                 $fieldDef['len']  = '10,0';
1017                         }
1018                 }
1019         }
1020
1021         /**
1022          * Generates SQL for dropping a table.
1023          *
1024          * @param  string $name table name
1025          * @return string SQL statement
1026          */
1027         public function dropTableNameSQL($name)
1028         {
1029                 return "DROP TABLE IF EXISTS ".$name;
1030         }
1031
1032         public function dropIndexes($tablename, $indexes, $execute = true)
1033         {
1034                 $sql = array();
1035                 foreach ($indexes as $index) {
1036                         $name =$index['name'];
1037                         if($execute) {
1038                         unset(self::$index_descriptions[$tablename][$name]);
1039                         }
1040                         if ($index['type'] == 'primary') {
1041                                 $sql[] = 'DROP PRIMARY KEY';
1042                         } else {
1043                                 $sql[] = "DROP INDEX $name";
1044                         }
1045                 }
1046                 if (!empty($sql)) {
1047                         $sql = "ALTER TABLE $tablename ".join(",", $sql);
1048                         if($execute)
1049                                 $this->query($sql);
1050                 } else {
1051                         $sql = '';
1052                 }
1053                 return $sql;
1054         }
1055
1056         /**
1057          * List of available collation settings
1058          * @return string
1059          */
1060         public function getDefaultCollation()
1061         {
1062                 return "utf8_general_ci";
1063         }
1064
1065         /**
1066          * List of available collation settings
1067          * @return array
1068          */
1069         public function getCollationList()
1070         {
1071                 $q = "SHOW COLLATION LIKE 'utf8%'";
1072                 $r = $this->query($q);
1073                 $res = array();
1074                 while($a = $this->fetchByAssoc($r)) {
1075                         $res[] = $a['Collation'];
1076                 }
1077                 return $res;
1078         }
1079
1080         /**
1081          * (non-PHPdoc)
1082          * @see DBManager::renameColumnSQL()
1083          */
1084         public function renameColumnSQL($tablename, $column, $newname)
1085         {
1086                 $field = $this->describeField($column, $tablename);
1087                 $field['name'] = $newname;
1088                 return "ALTER TABLE $tablename CHANGE COLUMN $column ".$this->oneColumnSQLRep($field);
1089         }
1090
1091         public function emptyValue($type)
1092         {
1093                 $ctype = $this->getColumnType($type);
1094                 if($ctype == "datetime") {
1095                         return $this->convert($this->quoted("0000-00-00 00:00:00"), "datetime");
1096                 }
1097                 if($ctype == "date") {
1098                         return $this->convert($this->quoted("0000-00-00"), "date");
1099                 }
1100                 if($ctype == "time") {
1101                         return $this->convert($this->quoted("00:00:00"), "time");
1102                 }
1103                 return parent::emptyValue($type);
1104         }
1105
1106         /**
1107          * (non-PHPdoc)
1108          * @see DBManager::lastDbError()
1109          */
1110         public function lastDbError()
1111         {
1112                 if($this->database) {
1113                     if(mysql_errno($this->database)) {
1114                             return "MySQL error ".mysql_errno($this->database).": ".mysql_error($this->database);
1115                     }
1116                 } else {
1117                         $err =  mysql_error();
1118                         if($err) {
1119                             return $err;
1120                         }
1121                 }
1122         return false;
1123     }
1124
1125         /**
1126          * Quote MySQL search term
1127          * @param unknown_type $term
1128          */
1129         protected function quoteTerm($term)
1130         {
1131                 if(strpos($term, ' ') !== false) {
1132                         return '"'.$term.'"';
1133                 }
1134                 return $term;
1135         }
1136
1137         /**
1138          * Generate fulltext query from set of terms
1139          * @param string $fields Field to search against
1140          * @param array $terms Search terms that may be or not be in the result
1141          * @param array $must_terms Search terms that have to be in the result
1142          * @param array $exclude_terms Search terms that have to be not in the result
1143          */
1144         public function getFulltextQuery($field, $terms, $must_terms = array(), $exclude_terms = array())
1145         {
1146                 $condition = array();
1147                 foreach($terms as $term) {
1148                         $condition[] = $this->quoteTerm($term);
1149                 }
1150                 foreach($must_terms as $term) {
1151                         $condition[] = "+".$this->quoteTerm($term);
1152                 }
1153                 foreach($exclude_terms as $term) {
1154                         $condition[] = "-".$this->quoteTerm($term);
1155                 }
1156                 $condition = $this->quoted(join(" ",$condition));
1157                 return "MATCH($field) AGAINST($condition IN BOOLEAN MODE)";
1158         }
1159
1160         /**
1161          * Get list of all defined charsets
1162          * @return array
1163          */
1164         protected function getCharsetInfo()
1165         {
1166                 $charsets = array();
1167                 $res = $this->query("show variables like 'character\\_set\\_%'");
1168                 while($row = $this->fetchByAssoc($res)) {
1169                         $charsets[$row['Variable_name']] = $row['Value'];
1170                 }
1171                 return $charsets;
1172         }
1173
1174         public function getDbInfo()
1175         {
1176                 $charsets = $this->getCharsetInfo();
1177                 $charset_str = array();
1178                 foreach($charsets as $name => $value) {
1179                         $charset_str[] = "$name = $value";
1180                 }
1181                 return array(
1182                         "MySQL Version" => @mysql_get_client_info(),
1183                         "MySQL Host Info" => @mysql_get_host_info($this->database),
1184                         "MySQL Server Info" => @mysql_get_server_info($this->database),
1185                         "MySQL Client Encoding" =>  @mysql_client_encoding($this->database),
1186                         "MySQL Character Set Settings" => join(", ", $charset_str),
1187                 );
1188         }
1189
1190         public function validateQuery($query)
1191         {
1192                 $res = $this->query("EXPLAIN $query");
1193                 return !empty($res);
1194         }
1195
1196         protected function makeTempTableCopy($table)
1197         {
1198                 $this->log->debug("creating temp table for [$table]...");
1199                 $result = $this->query("SHOW CREATE TABLE {$table}");
1200                 if(empty($result)) {
1201                         return false;
1202                 }
1203                 $row = $this->fetchByAssoc($result);
1204                 if(empty($row) || empty($row['Create Table'])) {
1205                     return false;
1206                 }
1207                 $create = $row['Create Table'];
1208                 // rewrite DDL with _temp name
1209                 $tempTableQuery = str_replace("CREATE TABLE `{$table}`", "CREATE TABLE `{$table}__uw_temp`", $create);
1210                 $r2 = $this->query($tempTableQuery);
1211                 if(empty($r2)) {
1212                         return false;
1213                 }
1214
1215                 // get sample data into the temp table to test for data/constraint conflicts
1216                 $this->log->debug('inserting temp dataset...');
1217                 $q3 = "INSERT INTO `{$table}__uw_temp` SELECT * FROM `{$table}` LIMIT 10";
1218                 $this->query($q3, false, "Preflight Failed for: {$q3}");
1219                 return true;
1220         }
1221
1222         /**
1223          * Tests an ALTER TABLE query
1224          * @param string table The table name to get DDL
1225          * @param string query The query to test.
1226          * @return string Non-empty if error found
1227          */
1228         protected function verifyAlterTable($table, $query)
1229         {
1230                 $this->log->debug("verifying ALTER TABLE");
1231                 // Skipping ALTER TABLE [table] DROP PRIMARY KEY because primary keys are not being copied
1232                 // over to the temp tables
1233                 if(strpos(strtoupper($query), 'DROP PRIMARY KEY') !== false) {
1234                         $this->log->debug("Skipping DROP PRIMARY KEY");
1235                         return '';
1236                 }
1237                 if(!$this->makeTempTableCopy($table)) {
1238                         return 'Could not create temp table copy';
1239                 }
1240
1241                 // test the query on the test table
1242                 $this->log->debug('testing query: ['.$query.']');
1243                 $tempTableTestQuery = str_replace("ALTER TABLE `{$table}`", "ALTER TABLE `{$table}__uw_temp`", $query);
1244                 if (strpos($tempTableTestQuery, 'idx') === false) {
1245                         if(strpos($tempTableTestQuery, '__uw_temp') === false) {
1246                                 return 'Could not use a temp table to test query!';
1247                         }
1248
1249                         $this->log->debug('testing query on temp table: ['.$tempTableTestQuery.']');
1250                         $this->query($tempTableTestQuery, false, "Preflight Failed for: {$query}");
1251                 } else {
1252                         // test insertion of an index on a table
1253                         $tempTableTestQuery_idx = str_replace("ADD INDEX `idx_", "ADD INDEX `temp_idx_", $tempTableTestQuery);
1254                         $this->log->debug('testing query on temp table: ['.$tempTableTestQuery_idx.']');
1255                         $this->query($tempTableTestQuery_idx, false, "Preflight Failed for: {$query}");
1256                 }
1257                 $mysqlError = $this->getL();
1258                 if(!empty($mysqlError)) {
1259                         return $mysqlError;
1260                 }
1261                 $this->dropTableName("{$table}__uw_temp");
1262
1263                 return '';
1264         }
1265
1266         protected function verifyGenericReplaceQuery($querytype, $table, $query)
1267         {
1268                 $this->log->debug("verifying $querytype statement");
1269
1270                 if(!$this->makeTempTableCopy($table)) {
1271                         return 'Could not create temp table copy';
1272                 }
1273                 // test the query on the test table
1274                 $this->log->debug('testing query: ['.$query.']');
1275                 $tempTableTestQuery = str_replace("$querytype `{$table}`", "$querytype `{$table}__uw_temp`", $query);
1276                 if(strpos($tempTableTestQuery, '__uw_temp') === false) {
1277                         return 'Could not use a temp table to test query!';
1278                 }
1279
1280                 $this->query($tempTableTestQuery, false, "Preflight Failed for: {$query}");
1281                 $error = $this->lastError(); // empty on no-errors
1282                 $this->dropTableName("{$table}__uw_temp"); // just in case
1283                 return $error;
1284         }
1285
1286         /**
1287          * Tests a DROP TABLE query
1288          * @param string table The table name to get DDL
1289          * @param string query The query to test.
1290          * @return string Non-empty if error found
1291          */
1292         public function verifyDropTable($table, $query)
1293         {
1294                 return $this->verifyGenericReplaceQuery("DROP TABLE", $table, $query);
1295         }
1296
1297         /**
1298          * Tests an INSERT INTO query
1299          * @param string table The table name to get DDL
1300          * @param string query The query to test.
1301          * @return string Non-empty if error found
1302          */
1303         public function verifyInsertInto($table, $query)
1304         {
1305                 return $this->verifyGenericReplaceQuery("INSERT INTO", $table, $query);
1306         }
1307
1308         /**
1309          * Tests an UPDATE query
1310          * @param string table The table name to get DDL
1311          * @param string query The query to test.
1312          * @return string Non-empty if error found
1313          */
1314         public function verifyUpdate($table, $query)
1315         {
1316                 return $this->verifyGenericReplaceQuery("UPDATE", $table, $query);
1317         }
1318
1319         /**
1320          * Tests an DELETE FROM query
1321          * @param string table The table name to get DDL
1322          * @param string query The query to test.
1323          * @return string Non-empty if error found
1324          */
1325         public function verifyDeleteFrom($table, $query)
1326         {
1327                 return $this->verifyGenericReplaceQuery("DELETE FROM", $table, $query);
1328         }
1329
1330         /**
1331          * Check if certain database exists
1332          * @param string $dbname
1333          */
1334         public function dbExists($dbname)
1335         {
1336                 $db = $this->getOne("SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ".$this->quoted($dbname));
1337                 return !empty($db);
1338         }
1339
1340         /**
1341          * Select database
1342          * @param string $dbname
1343          */
1344         protected function selectDb($dbname)
1345         {
1346                 return mysql_select_db($dbname);
1347         }
1348
1349         /**
1350          * Check if certain DB user exists
1351          * @param string $username
1352          */
1353         public function userExists($username)
1354         {
1355                 $db = $this->getOne("SELECT DATABASE()");
1356                 if(!$this->selectDb("mysql")) {
1357                         return false;
1358                 }
1359                 $user = $this->getOne("select count(*) from user where user = ".$this->quoted($username));
1360                 if(!$this->selectDb($db)) {
1361                         $this->checkError("Cannot select database $db", true);
1362                 }
1363                 return !empty($user);
1364         }
1365
1366         /**
1367          * Create DB user
1368          * @param string $database_name
1369          * @param string $host_name
1370          * @param string $user
1371          * @param string $password
1372          */
1373         public function createDbUser($database_name, $host_name, $user, $password)
1374         {
1375                 $qpassword = $this->quote($password);
1376                 $this->query("GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP, INDEX
1377                                                         ON `$database_name`.*
1378                                                         TO \"$user\"@\"$host_name\"
1379                                                         IDENTIFIED BY '{$qpassword}';", true);
1380
1381                 $this->query("SET PASSWORD FOR \"{$user}\"@\"{$host_name}\" = password('{$qpassword}');", true);
1382                 if($host_name != 'localhost') {
1383                         $this->createDbUser($database_name, "localhost", $user, $password);
1384                 }
1385         }
1386
1387         /**
1388          * Create a database
1389          * @param string $dbname
1390          */
1391         public function createDatabase($dbname)
1392         {
1393                 $this->query("CREATE DATABASE `$dbname` CHARACTER SET utf8 COLLATE utf8_general_ci", true);
1394         }
1395
1396         public function preInstall()
1397         {
1398                 $db->query("ALTER DATABASE `{$setup_db_database_name}` DEFAULT CHARACTER SET utf8", true);
1399                 $db->query("ALTER DATABASE `{$setup_db_database_name}` DEFAULT COLLATE utf8_general_ci", true);
1400
1401         }
1402
1403         /**
1404          * Drop a database
1405          * @param string $dbname
1406          */
1407         public function dropDatabase($dbname)
1408         {
1409                 return $this->query("DROP DATABASE IF EXISTS `$dbname`", true);
1410         }
1411
1412         /**
1413          * Check if this driver can be used
1414          * @return bool
1415          */
1416         public function valid()
1417         {
1418                 return function_exists("mysql_connect");
1419         }
1420
1421         /**
1422          * Check DB version
1423          * @see DBManager::canInstall()
1424          */
1425         public function canInstall()
1426         {
1427                 $db_version = $this->version();
1428                 if(empty($db_version)) {
1429                         return array('ERR_DB_VERSION_FAILURE');
1430                 }
1431                 if(version_compare($db_version, '4.1.2') < 0) {
1432                         return array('ERR_DB_MYSQL_VERSION', $db_version);
1433                 }
1434                 return true;
1435         }
1436
1437         public function installConfig()
1438         {
1439                 return array(
1440                         'LBL_DBCONFIG_MSG3' =>  array(
1441                                 "setup_db_database_name" => array("label" => 'LBL_DBCONF_DB_NAME', "required" => true),
1442                         ),
1443                         'LBL_DBCONFIG_MSG2' =>  array(
1444                                 "setup_db_host_name" => array("label" => 'LBL_DBCONF_HOST_NAME', "required" => true),
1445                         ),
1446                         'LBL_DBCONF_TITLE_USER_INFO' => array(),
1447                         'LBL_DBCONFIG_B_MSG1' => array(
1448                                 "setup_db_admin_user_name" => array("label" => 'LBL_DBCONF_DB_ADMIN_USER', "required" => true),
1449                                 "setup_db_admin_password" => array("label" => 'LBL_DBCONF_DB_ADMIN_PASSWORD', "type" => "password"),
1450                         )
1451                 );
1452         }
1453
1454         /**
1455          * Disable keys on the table
1456          * @abstract
1457          * @param string $tableName
1458          */
1459         public function disableKeys($tableName)
1460         {
1461             return $this->query('ALTER TABLE '.$tableName.' DISABLE KEYS');
1462         }
1463
1464         /**
1465          * Re-enable keys on the table
1466          * @abstract
1467          * @param string $tableName
1468          */
1469         public function enableKeys($tableName)
1470         {
1471             return $this->query('ALTER TABLE '.$tableName.' ENABLE KEYS');
1472         }
1473
1474     /**
1475      * Returns a DB specific FROM clause which can be used to select against functions.
1476      * Note that depending on the database that this may also be an empty string.
1477      * @return string
1478      */
1479     public function getFromDummyTable()
1480     {
1481         return '';
1482     }
1483
1484     /**
1485      * Returns a DB specific piece of SQL which will generate GUID (UUID)
1486      * This string can be used in dynamic SQL to do multiple inserts with a single query.
1487      * I.e. generate a unique Sugar id in a sub select of an insert statement.
1488      * @return string
1489      */
1490
1491         public function getGuidSQL()
1492     {
1493         return 'UUID()';
1494     }
1495 }