mysql_outputter.php
Current file: src/processor/mysql_outputter.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
0.00% 0 / 1
0.00% 0 / 17 CRAP
0.00% 0 / 90
MysqlOutputter
0.00% 0 / 1
0.00% 0 / 17 1892
0.00% 0 / 90
 __construct($username, $password, $server, $database)
0.00% 0 / 1 2
0.00% 0 / 5
 __destruct()
0.00% 0 / 1 6
0.00% 0 / 2
 connect()
0.00% 0 / 1 6
0.00% 0 / 4
 query($query)
0.00% 0 / 1 6
0.00% 0 / 5
 sql_safen($input)
0.00% 0 / 1 12
0.00% 0 / 5
 fetch_row($res)
0.00% 0 / 1 2
0.00% 0 / 1
 fetch_assoc($res)
0.00% 0 / 1 2
0.00% 0 / 1
 affected_rows($res)
0.00% 0 / 1 2
0.00% 0 / 1
 insert_id()
0.00% 0 / 1 2
0.00% 0 / 1
 get_table_list()
0.00% 0 / 1 6
0.00% 0 / 7
 get_sql_type($internal_type_name)
0.00% 0 / 1 42
0.00% 0 / 8
 get_column_details($table_name)
0.00% 0 / 1 182
0.00% 0 / 29
 get_alter_column_query($table, $column_name, $new_type, $not_null)
0.00% 0 / 1 2
0.00% 0 / 3
 create_table($table_name, $dest_table)
0.00% 0 / 1 20
0.00% 0 / 12
 start_transaction()
0.00% 0 / 1 2
0.00% 0 / 2
 commit_transaction()
0.00% 0 / 1 2
0.00% 0 / 2
 rollback_transaction()
0.00% 0 / 1 2
0.00% 0 / 2


       1                 : <?php                                                                                                                       
       2                 : /*                                                                                                                          
       3                 : Copyright 2008 Josh Heidenreich                                                                                             
       4                 :                                                                                                                             
       5                 : This file is part of Pelzini.                                                                                               
       6                 :                                                                                                                             
       7                 : Pelzini is free software: you can redistribute it and/or modify                                                             
       8                 : it under the terms of the GNU General Public License as published by                                                        
       9                 : the Free Software Foundation, either version 3 of the License, or                                                           
      10                 : (at your option) any later version.                                                                                         
      11                 :                                                                                                                             
      12                 : Pelzini is distributed in the hope that it will be useful,                                                                  
      13                 : but WITHOUT ANY WARRANTY; without even the implied warranty of                                                              
      14                 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                                               
      15                 : GNU General Public License for more details.                                                                                
      16                 :                                                                                                                             
      17                 : You should have received a copy of the GNU General Public License                                                           
      18                 : along with Pelzini.  If not, see <http://www.gnu.org/licenses/>.                                                            
      19                 : */                                                                                                                          
      20                 :                                                                                                                             
      21                 :                                                                                                                             
      22                 : /**                                                                                                                         
      23                 :  * Contains the {@link MysqlOutputter} class                                                                                
      24                 :  *                                                                                                                          
      25                 :  * @package Outputters                                                                                                      
      26                 :  * @author Josh                                                                                                             
      27                 :  * @since 0.1                                                                                                               
      28                 :  **/                                                                                                                        
      29                 :                                                                                                                             
      30                 : /**                                                                                                                         
      31                 :  * Outputs the tree as MySQL                                                                                                
      32                 :  **/                                                                                                                        
      33                 : class MysqlOutputter extends DatabaseOutputter {                                                                            
      34                 :     private $username;                                                                                                      
      35                 :     private $password;                                                                                                      
      36                 :     private $server;                                                                                                        
      37                 :     private $database;                                                                                                      
      38                 :     private $db;                                                                                                            
      39                 :                                                                                                                             
      40                 :     /**                                                                                                                     
      41                 :      * Connects to the db                                                                                                   
      42                 :      */                                                                                                                     
      43                 :     public function __construct($username, $password, $server, $database)                                                   
      44                 :     {                                                                                                                       
      45               0 :         $this->username = $username;                                                                                        
      46               0 :         $this->password = $password;                                                                                        
      47               0 :         $this->server = $server;                                                                                            
      48               0 :         $this->database = $database;                                                                                        
      49               0 :     }                                                                                                                       
      50                 :                                                                                                                             
      51                 :                                                                                                                             
      52                 :     /**                                                                                                                     
      53                 :      * Closes connection to the db                                                                                          
      54                 :      */                                                                                                                     
      55                 :     public function __destruct()                                                                                            
      56                 :     {                                                                                                                       
      57               0 :         if ($this->db) mysql_close($this->db);                                                                              
      58               0 :     }                                                                                                                       
      59                 :                                                                                                                             
      60                 :                                                                                                                             
      61                 :                                                                                                                             
      62                 :     /**                                                                                                                     
      63                 :      * Connects to the MySQL database                                                                                       
      64                 :      **/                                                                                                                    
      65                 :     protected function connect()                                                                                            
      66                 :     {                                                                                                                       
      67               0 :         $this->db = @mysql_connect($this->server, $this->username, $this->password);                                        
      68               0 :         if ($this->db == false) return false;                                                                               
      69               0 :         mysql_select_db($this->database, $this->db);                                                                        
      70               0 :         return true;                                                                                                        
      71                 :     }                                                                                                                       
      72                 :                                                                                                                             
      73                 :                                                                                                                             
      74                 :     /**                                                                                                                     
      75                 :      * Executes a MySQL query                                                                                               
      76                 :      */                                                                                                                     
      77                 :     protected function query($query)                                                                                        
      78                 :     {                                                                                                                       
      79               0 :         $return = mysql_query($query, $this->db);                                                                           
      80               0 :         if ($return === false) {                                                                                            
      81               0 :             echo "<p>Error in query <em>{$query}</em>. MySQL reported the following: <em>" . mysql_error() . "</em></p>";   
      82               0 :         }                                                                                                                   
      83               0 :         return $return;                                                                                                     
      84                 :     }                                                                                                                       
      85                 :                                                                                                                             
      86                 :                                                                                                                             
      87                 :     /**                                                                                                                     
      88                 :      * Safens some input                                                                                                    
      89                 :      * @param string $input The input to safen                                                                              
      90                 :      **/                                                                                                                    
      91                 :     protected function sql_safen($input)                                                                                    
      92                 :     {                                                                                                                       
      93               0 :         if ($input === null) {                                                                                              
      94               0 :             return 'NULL';                                                                                                  
      95               0 :         } else if (is_integer($input)) {                                                                                    
      96               0 :             return $input;                                                                                                  
      97                 :         } else {                                                                                                            
      98               0 :             return "'" . mysql_real_escape_string($input, $this->db) . "'";                                                 
      99                 :         }                                                                                                                   
     100                 :     }                                                                                                                       
     101                 :                                                                                                                             
     102                 :                                                                                                                             
     103                 :     /**                                                                                                                     
     104                 :      * Fetches a row from the database (numerical)                                                                          
     105                 :      **/                                                                                                                    
     106                 :     protected function fetch_row($res)                                                                                      
     107                 :     {                                                                                                                       
     108               0 :         return mysql_fetch_row($res);                                                                                       
     109                 :     }                                                                                                                       
     110                 :                                                                                                                             
     111                 :                                                                                                                             
     112                 :     /**                                                                                                                     
     113                 :      * Fetches a row from the database (assoc)                                                                              
     114                 :      **/                                                                                                                    
     115                 :     protected function fetch_assoc($res)                                                                                    
     116                 :     {                                                                                                                       
     117               0 :         return mysql_fetch_assoc($res);                                                                                     
     118                 :     }                                                                                                                       
     119                 :                                                                                                                             
     120                 :                                                                                                                             
     121                 :     /**                                                                                                                     
     122                 :      * Returns the number of rows affected in the last query                                                                
     123                 :      **/                                                                                                                    
     124                 :     protected function affected_rows($res)                                                                                  
     125                 :     {                                                                                                                       
     126               0 :         return mysql_affected_rows();                                                                                       
     127                 :     }                                                                                                                       
     128                 :                                                                                                                             
     129                 :                                                                                                                             
     130                 :     /**                                                                                                                     
     131                 :      * Returns the autogenerated id created in the last query                                                               
     132                 :      **/                                                                                                                    
     133                 :     protected function insert_id()                                                                                          
     134                 :     {                                                                                                                       
     135               0 :         return mysql_insert_id();                                                                                           
     136                 :     }                                                                                                                       
     137                 :                                                                                                                             
     138                 :                                                                                                                             
     139                 :     /**                                                                                                                     
     140                 :      * Returns an array of the tables in this database                                                                      
     141                 :      **/                                                                                                                    
     142                 :     protected function get_table_list()                                                                                     
     143                 :     {                                                                                                                       
     144               0 :         $q = "SHOW TABLES";                                                                                                 
     145               0 :         $res = $this->query ($q);                                                                                           
     146                 :                                                                                                                             
     147               0 :         $tables = array();                                                                                                  
     148               0 :         while ($row = $this->fetch_row($res)) {                                                                             
     149               0 :             $tables[] = $row[0];                                                                                            
     150               0 :         }                                                                                                                   
     151                 :                                                                                                                             
     152               0 :         return $tables;                                                                                                     
     153                 :     }                                                                                                                       
     154                 :                                                                                                                             
     155                 :                                                                                                                             
     156                 :     /**                                                                                                                     
     157                 :      * Converts an internal type into the database-specific SQL type.                                                       
     158                 :      * The defined internal types are:                                                                                      
     159                 :      *   - serial: a number that automatically increments whenever a record is added                                        
     160                 :      *   - smallnum: a small number. needs to be able to hold at least 32,767 possible values (e.g. a 16-bit signed integer)
     161                 :      *   - largenum: a large number. needs to be the same size or larger than a serial type                                 
     162                 :      *   - string: a character field long enough to hold identifiers of objects (e.g. function names)                       
     163                 :      *   - text: a field that can hold arbitary pieces of text larger than 65536 chars in length.                           
     164                 :      *                                                                                                                      
     165                 :      * @param string $internal_type_name The internal type name.                                                            
     166                 :      * @return string The name used by the SQL database.                                                                    
     167                 :      **/                                                                                                                    
     168                 :     protected function get_sql_type($internal_type_name)                                                                    
     169                 :     {                                                                                                                       
     170                 :         switch ($internal_type_name) {                                                                                      
     171               0 :         case 'serial': return 'SERIAL';                                                                                     
     172               0 :         case 'smallnum': return 'SMALLINT UNSIGNED';                                                                        
     173               0 :         case 'largenum': return 'BIGINT UNSIGNED';                                                                          
     174               0 :         case 'string': return 'VARCHAR(255)';                                                                               
     175               0 :         case 'text': return 'MEDIUMTEXT';                                                                                   
     176               0 :         default:                                                                                                            
     177               0 :             throw new Exception ("Undefined type '{$internal_type_name}' specified");                                       
     178                 :             break;                                                                                                          
     179               0 :         }                                                                                                                   
     180                 :     }                                                                                                                       
     181                 :                                                                                                                             
     182                 :                                                                                                                             
     183                 :     /**                                                                                                                     
     184                 :      * Should return a multi-dimentional array of the column details                                                        
     185                 :      * Format:                                                                                                              
     186                 :      * Array [                                                                                                              
     187                 :      *   [0] => Array [                                                                                                     
     188                 :      *      'Field' => field name                                                                                           
     189                 :      *      'Type' => field type, (e.g. 'serial', 'smallnum' or 'identifier')                                               
     190                 :      *      'NotNull' => nullable?, (true or false)                                                                         
     191                 :      *      'Key' => indexed?, ('PRI' for primary key)                                                                      
     192                 :      *      ]                                                                                                               
     193                 :      *    [1] => ...                                                                                                        
     194                 :      *    [n] => ...                                                                                                        
     195                 :      **/                                                                                                                    
     196                 :     protected function get_column_details($table_name)                                                                      
     197                 :     {                                                                                                                       
     198               0 :         $q = 'SHOW COLUMNS IN ' . $table_name;                                                                              
     199               0 :         $res = $this->query ($q);                                                                                           
     200                 :                                                                                                                             
     201               0 :         $columns = array();                                                                                                 
     202               0 :         while ($row = $this->fetch_assoc($res)) {                                                                           
     203               0 :             if ($row['Null'] == 'YES') {                                                                                    
     204               0 :                 $row['NotNull'] = false;                                                                                    
     205               0 :             } else {                                                                                                        
     206               0 :                 $row['NotNull'] = true;                                                                                     
     207                 :             }                                                                                                               
     208                 :                                                                                                                             
     209                 :             // Remap the SQL types back to Pelzini type                                                                     
     210               0 :             $row['Type'] = preg_replace('/\(.+\)/', '', $row['Type']);                                                      
     211               0 :             $row['Type'] = strtolower($row['Type']);                                                                        
     212               0 :             switch ($row['Type']) {                                                                                         
     213               0 :             case 'smallint unsigned': $row['Type'] = 'smallnum'; break;                                                     
     214               0 :             case 'smallint': $row['Type'] = 'smallnum'; break;                                                              
     215               0 :             case 'bigint unsigned':                                                                                         
     216               0 :                 $row['Type'] = 'largenum';                                                                                  
     217               0 :                 if ($row['NotNull'] and stripos('auto_increment', $row['Extra']) !== false) {                               
     218               0 :                     $row['Type'] = 'serial';                                                                                
     219               0 :                 }                                                                                                           
     220               0 :                 break;                                                                                                      
     221               0 :             case 'bigint': $row['Type'] = 'largenum'; break;                                                                
     222               0 :             case 'int unsigned': $row['Type'] = 'largenum'; break;                                                          
     223               0 :             case 'int': $row['Type'] = 'largenum'; break;                                                                   
     224               0 :             case 'varchar': $row['Type'] = 'string'; break;                                                                 
     225               0 :             case 'mediumtext': $row['Type'] = 'text'; break;                                                                
     226               0 :             }                                                                                                               
     227                 :                                                                                                                             
     228               0 :             unset ($row['Extra'], $row['Default']);                                                                         
     229               0 :             $columns[] = $row;                                                                                              
     230               0 :         }                                                                                                                   
     231                 :                                                                                                                             
     232               0 :         return $columns;                                                                                                    
     233                 :     }                                                                                                                       
     234                 :                                                                                                                             
     235                 :                                                                                                                             
     236                 :     /**                                                                                                                     
     237                 :      * Gets the query that alters a column to match the new SQL definition                                                  
     238                 :      **/                                                                                                                    
     239                 :     protected function get_alter_column_query($table, $column_name, $new_type, $not_null)                                   
     240                 :     {                                                                                                                       
     241               0 :         $new_type = $this->get_sql_type($new_type);                                                                         
     242                 :                                                                                                                             
     243               0 :         $q = "ALTER TABLE {$table} MODIFY COLUMN {$column_name} {$new_type}";                                               
     244               0 :         return $q;                                                                                                          
     245                 :     }                                                                                                                       
     246                 :                                                                                                                             
     247                 :                                                                                                                             
     248                 :     /**                                                                                                                     
     249                 :      * Creates a table                                                                                                      
     250                 :      **/                                                                                                                    
     251                 :     protected function create_table($table_name, $dest_table)                                                               
     252                 :     {                                                                                                                       
     253               0 :         $q = "CREATE TABLE {$table_name} (\n";                                                                              
     254               0 :         foreach ($dest_table['Columns'] as $col_name => $col_def) {                                                         
     255               0 :             $dest_sql = $this->get_sql_type($col_def['Type']);                                                              
     256               0 :             if ($col_def['NotNull']) $dest_sql .= ' not null';                                                              
     257                 :                                                                                                                             
     258               0 :             $q .= "  {$col_name} {$dest_sql},\n";                                                                           
     259               0 :         }                                                                                                                   
     260               0 :         $q .= "  PRIMARY KEY ({$dest_table['PK']})\n";                                                                      
     261               0 :         $q .= ") ENGINE=MyISAM";                                                                                            
     262               0 :         echo "<b>Query:\n{$q}</b>\n";                                                                                       
     263                 :                                                                                                                             
     264               0 :         $res = $this->query ($q);                                                                                           
     265               0 :         if ($res) echo 'Affected rows: ', $this->affected_rows($res), "\n";                                                 
     266               0 :     }                                                                                                                       
     267                 :                                                                                                                             
     268                 :                                                                                                                             
     269                 :     /**                                                                                                                     
     270                 :      * The database engine should start a transaction. If transactions are not supported, it should do nothing.             
     271                 :      **/                                                                                                                    
     272                 :     protected function start_transaction()                                                                                  
     273                 :     {                                                                                                                       
     274               0 :         $this->query('START TRANSACTION');                                                                                  
     275               0 :     }                                                                                                                       
     276                 :                                                                                                                             
     277                 :                                                                                                                             
     278                 :     /**                                                                                                                     
     279                 :      * The database engine should commit a transaction. If transactions are not supported, it should do nothing.            
     280                 :      **/                                                                                                                    
     281                 :     protected function commit_transaction()                                                                                 
     282                 :     {                                                                                                                       
     283               0 :         $this->query('COMMIT');                                                                                             
     284               0 :     }                                                                                                                       
     285                 :                                                                                                                             
     286                 :                                                                                                                             
     287                 :     /**                                                                                                                     
     288                 :      * The database engine should rollback a transaction. If transactions are not supported, it should do nothing.          
     289                 :      **/                                                                                                                    
     290                 :     protected function rollback_transaction()                                                                               
     291                 :     {                                                                                                                       
     292               0 :         $this->query('ROLLBACK');                                                                                           
     293               0 :     }                                                                                                                       
     294                 :                                                                                                                             
     295                 :                                                                                                                             
     296                 : }                                                                                                                           
     297                 :                                                                                                                             
     298                 :                                                                                                                             
     299                 : ?>                                                                                                                          

Generated by PHP_CodeCoverage 1.1.2 using PHP 5.4.39-0+deb7u2 and PHPUnit 3.6.10 at Fri Sep 11 11:35:19 WIT 2015.