database_outputter.php
Current file: src/processor/database_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 / 443
DatabaseOutputter
0.00% 0 / 1
46.88% 15 / 32 11772
0.00% 0 / 443
 connect()
100.00% 1 / 1 1
100.00% 0 / 0
 query($query)
100.00% 1 / 1 1
100.00% 0 / 0
 sql_safen($input)
100.00% 1 / 1 1
100.00% 0 / 0
 fetch_row($res)
100.00% 1 / 1 1
100.00% 0 / 0
 fetch_assoc($res)
100.00% 1 / 1 1
100.00% 0 / 0
 affected_rows($res)
100.00% 1 / 1 1
100.00% 0 / 0
 insert_id()
100.00% 1 / 1 1
100.00% 0 / 0
 get_table_list()
100.00% 1 / 1 1
100.00% 0 / 0
 get_column_details($table_name)
100.00% 1 / 1 1
100.00% 0 / 0
 get_alter_column_query($table, $column_name, $new_type, $null_allowed)
100.00% 1 / 1 1
100.00% 0 / 0
 get_sql_type($internal_type_name)
100.00% 1 / 1 1
100.00% 0 / 0
 create_table($table_name, $columns)
100.00% 1 / 1 1
100.00% 0 / 0
 start_transaction()
100.00% 1 / 1 1
100.00% 0 / 0
 commit_transaction()
100.00% 1 / 1 1
100.00% 0 / 0
 rollback_transaction()
100.00% 1 / 1 1
100.00% 0 / 0
 do_insert($table, $data)
0.00% 0 / 1 2
0.00% 0 / 8
 do_multiple_insert($table, $data)
0.00% 0 / 1 20
0.00% 0 / 11
 do_update($table, $data, $where)
0.00% 0 / 1 30
0.00% 0 / 14
 check_layout($layout_filename)
0.00% 0 / 1 506
0.00% 0 / 79
 addSinceVersion(CodeParserItem $parser_item, $parent)
0.00% 0 / 1 12
0.00% 0 / 5
 getSinceVersionId($since_version)
0.00% 0 / 1 6
0.00% 0 / 3
 output($files, Config $config)
0.00% 0 / 1 420
0.00% 0 / 113
 save_function($function, $file_id, $class_id, $interface_id, $file_namespace)
0.00% 0 / 1 156
0.00% 0 / 67
 save_class($class, $file_id, $file_namespace)
0.00% 0 / 1 42
0.00% 0 / 32
 save_interface($interface, $file_id, $file_namespace)
0.00% 0 / 1 6
0.00% 0 / 18
 save_variable($variable, $class_id = null, $interface_id = null)
0.00% 0 / 1 20
0.00% 0 / 17
 save_constant($constant, $file_id = null, $enumeration_id = null)
0.00% 0 / 1 6
0.00% 0 / 16
 save_enumeration($enumeration, $file_id = null)
0.00% 0 / 1 6
0.00% 0 / 16
 save_author_items($link_type, $link_id, $items)
0.00% 0 / 1 6
0.00% 0 / 12
 save_table_items($link_type, $link_id, $items)
0.00% 0 / 1 6
0.00% 0 / 12
 save_see_items($link_type, $link_id, $items)
0.00% 0 / 1 6
0.00% 0 / 10
 save_info_tag_items($link_type, $link_id, $items)
0.00% 0 / 1 6
0.00% 0 / 10


       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 DatabaseOutputter} class                                                                                           
      24                 :  *                                                                                                                                        
      25                 :  * @package Outputters                                                                                                                    
      26                 :  * @author Josh                                                                                                                           
      27                 :  * @since 0.2                                                                                                                             
      28                 :  **/                                                                                                                                      
      29                 :                                                                                                                                           
      30                 : /**                                                                                                                                       
      31                 :  * Outputs the tree to a database.                                                                                                        
      32                 :  **/                                                                                                                                      
      33                 : abstract class DatabaseOutputter extends Outputter {                                                                                      
      34                 :     static private $since_versions;                                                                                                       
      35                 :     protected $extra_insert_data = array();                                                                                               
      36                 :                                                                                                                                           
      37                 :     /**                                                                                                                                   
      38                 :      * Connects to the database                                                                                                           
      39                 :      **/                                                                                                                                  
      40                 :     abstract protected function connect();                                                                                                
      41                 :                                                                                                                                           
      42                 :     /**                                                                                                                                   
      43                 :      * Executes a database query                                                                                                          
      44                 :      */                                                                                                                                   
      45                 :     abstract protected function query($query);                                                                                            
      46                 :                                                                                                                                           
      47                 :     /**                                                                                                                                   
      48                 :      * Safens some input                                                                                                                  
      49                 :      * @param string $input The input to safen                                                                                            
      50                 :      **/                                                                                                                                  
      51                 :     abstract protected function sql_safen($input);                                                                                        
      52                 :                                                                                                                                           
      53                 :                                                                                                                                           
      54                 :     /**                                                                                                                                   
      55                 :      * Fetches a row from the database (numerical)                                                                                        
      56                 :      **/                                                                                                                                  
      57                 :     abstract protected function fetch_row($res);                                                                                          
      58                 :                                                                                                                                           
      59                 :     /**                                                                                                                                   
      60                 :      * Fetches a row from the database (assoc)                                                                                            
      61                 :      **/                                                                                                                                  
      62                 :     abstract protected function fetch_assoc($res);                                                                                        
      63                 :                                                                                                                                           
      64                 :     /**                                                                                                                                   
      65                 :      * Returns the number of rows affected in the last query                                                                              
      66                 :      **/                                                                                                                                  
      67                 :     abstract protected function affected_rows($res);                                                                                      
      68                 :                                                                                                                                           
      69                 :     /**                                                                                                                                   
      70                 :      * Returns the autogenerated id created in the last query                                                                             
      71                 :      **/                                                                                                                                  
      72                 :     abstract protected function insert_id();                                                                                              
      73                 :                                                                                                                                           
      74                 :                                                                                                                                           
      75                 :     /**                                                                                                                                   
      76                 :      * Returns an array of the tables in this database                                                                                    
      77                 :      **/                                                                                                                                  
      78                 :     abstract protected function get_table_list();                                                                                         
      79                 :                                                                                                                                           
      80                 :     /**                                                                                                                                   
      81                 :      * Should return a multi-dimentional array of the column details                                                                      
      82                 :      * Format:                                                                                                                            
      83                 :      * Array [                                                                                                                            
      84                 :      *   [0] => Array [                                                                                                                   
      85                 :      *      'Field' => field name                                                                                                         
      86                 :      *      'Type' => field type, (e.g. 'serial', 'smallnum' or 'identifier')                                                             
      87                 :      *      'NotNull' => nullable?, (true or false)                                                                                       
      88                 :      *      'Key' => indexed?, ('PRI' for primary key)                                                                                    
      89                 :      *      ]                                                                                                                             
      90                 :      *    [1] => ...                                                                                                                      
      91                 :      *    [n] => ...                                                                                                                      
      92                 :      **/                                                                                                                                  
      93                 :     abstract protected function get_column_details($table_name);                                                                          
      94                 :                                                                                                                                           
      95                 :     /**                                                                                                                                   
      96                 :      * Gets the query that alters a column to match the new SQL definition                                                                
      97                 :      **/                                                                                                                                  
      98                 :     abstract protected function get_alter_column_query($table, $column_name, $new_type, $null_allowed);                                   
      99                 :                                                                                                                                           
     100                 :     /**                                                                                                                                   
     101                 :      * Converts an internal type into the database-specific SQL type.                                                                     
     102                 :      * The defined internal types are:                                                                                                    
     103                 :      *   - serial: a number that automatically increments whenever a record is added                                                      
     104                 :      *   - smallnum: a small number. needs to be able to hold at least 32,767 possible values (e.g. a 16-bit signed integer)              
     105                 :      *   - largenum: a large number. needs to be the same size or larger than a serial type                                               
     106                 :      *   - string: a character field long enough to hold identifiers of objects (e.g. function names)                                     
     107                 :      *   - text: a field that can hold arbitary pieces of text larger than 65536 chars in length.                                         
     108                 :      *                                                                                                                                    
     109                 :      * @param string $internal_type_name The internal type name.                                                                          
     110                 :      * @return string The name used by the SQL database.                                                                                  
     111                 :      **/                                                                                                                                  
     112                 :     abstract protected function get_sql_type($internal_type_name);                                                                        
     113                 :                                                                                                                                           
     114                 :     /**                                                                                                                                   
     115                 :      * Creates a table                                                                                                                    
     116                 :      **/                                                                                                                                  
     117                 :     abstract protected function create_table($table_name, $columns);                                                                      
     118                 :                                                                                                                                           
     119                 :     /**                                                                                                                                   
     120                 :      * The database engine should start a transaction. If transactions are not supported, it should do nothing.                           
     121                 :      **/                                                                                                                                  
     122                 :     abstract protected function start_transaction();                                                                                      
     123                 :                                                                                                                                           
     124                 :     /**                                                                                                                                   
     125                 :      * The database engine should commit a transaction. If transactions are not supported, it should do nothing.                          
     126                 :      **/                                                                                                                                  
     127                 :     abstract protected function commit_transaction();                                                                                     
     128                 :                                                                                                                                           
     129                 :     /**                                                                                                                                   
     130                 :      * The database engine should rollback a transaction. If transactions are not supported, it should do nothing.                        
     131                 :      **/                                                                                                                                  
     132                 :     abstract protected function rollback_transaction();                                                                                   
     133                 :                                                                                                                                           
     134                 :                                                                                                                                           
     135                 :     /**                                                                                                                                   
     136                 :      * Executes an insert query for the data provided.                                                                                    
     137                 :      **/                                                                                                                                  
     138                 :     protected function do_insert($table, $data)                                                                                           
     139                 :     {                                                                                                                                     
     140               0 :         $data += $this->extra_insert_data;                                                                                                
     141               0 :         $q = "INSERT INTO {$table} (";                                                                                                    
     142               0 :         $q .= implode(', ', array_keys($data));                                                                                           
     143               0 :         $q .= ") VALUES (";                                                                                                               
     144               0 :         $q .= implode(',', $data);                                                                                                        
     145               0 :         $q .= ")";                                                                                                                        
     146               0 :         $this->query($q);                                                                                                                 
     147               0 :     }                                                                                                                                     
     148                 :                                                                                                                                           
     149                 :                                                                                                                                           
     150                 :     /**                                                                                                                                   
     151                 :      * Executes an insert query for the data provided.                                                                                    
     152                 :      **/                                                                                                                                  
     153                 :     protected function do_multiple_insert($table, $data)                                                                                  
     154                 :     {                                                                                                                                     
     155               0 :         if (count($data) == 0) return;                                                                                                    
     156                 :                                                                                                                                           
     157               0 :         $q = "INSERT INTO {$table} (";                                                                                                    
     158               0 :         $q .= implode(',', array_keys($data[0] + $this->extra_insert_data));                                                              
     159               0 :         $q .= ") VALUES ";                                                                                                                
     160                 :                                                                                                                                           
     161               0 :         $j = 0;                                                                                                                           
     162               0 :         foreach ($data as $row) {                                                                                                         
     163               0 :             if ($j++ > 0) $q .= ',';                                                                                                      
     164               0 :             $q .= '(' . implode(',', $row + $this->extra_insert_data) . ')';                                                              
     165               0 :         }                                                                                                                                 
     166                 :                                                                                                                                           
     167               0 :         $this->query($q);                                                                                                                 
     168               0 :     }                                                                                                                                     
     169                 :                                                                                                                                           
     170                 :                                                                                                                                           
     171                 :     /**                                                                                                                                   
     172                 :      * Executes an update query for the data provided.                                                                                    
     173                 :      **/                                                                                                                                  
     174                 :     protected function do_update($table, $data, $where)                                                                                   
     175                 :     {                                                                                                                                     
     176               0 :         $q = "UPDATE {$table} SET ";                                                                                                      
     177               0 :         $j = 0;                                                                                                                           
     178               0 :         foreach ($data as $key => $val) {                                                                                                 
     179               0 :             if ($j++) $q .= ',';                                                                                                          
     180               0 :             $q .= $key . ' = ' . $val;                                                                                                    
     181               0 :         }                                                                                                                                 
     182               0 :         $q .= ' WHERE ';                                                                                                                  
     183               0 :         $j = 0;                                                                                                                           
     184               0 :         foreach ($where as $key => $val) {                                                                                                
     185               0 :             if ($j++) $q .= ',';                                                                                                          
     186               0 :             $q .= $key . ' = ' . $val;                                                                                                    
     187               0 :         }                                                                                                                                 
     188               0 :         $this->query($q);                                                                                                                 
     189               0 :     }                                                                                                                                     
     190                 :                                                                                                                                           
     191                 :                                                                                                                                           
     192                 :     /**                                                                                                                                   
     193                 :      * Updates the database layout to match the layout file                                                                               
     194                 :      * NOTE: currently only supports column and table adding and updating, not removal.                                                   
     195                 :      *                                                                                                                                    
     196                 :      * @param string $layout_filename The name of hte layout file to match                                                                
     197                 :      **/                                                                                                                                  
     198                 :     public function check_layout($layout_filename)                                                                                        
     199                 :     {                                                                                                                                     
     200               0 :         $layout_lines = file($layout_filename);                                                                                           
     201                 :                                                                                                                                           
     202               0 :         $res = $this->connect();                                                                                                          
     203               0 :         if (! $res) {                                                                                                                     
     204               0 :             echo "<p>Unable to connect to database!";                                                                                     
     205               0 :             return false;                                                                                                                 
     206                 :         }                                                                                                                                 
     207                 :                                                                                                                                           
     208               0 :         $dest_tables = array ();                                                                                                          
     209               0 :         $table = null;                                                                                                                    
     210                 :                                                                                                                                           
     211               0 :         foreach ($layout_lines as $line) {                                                                                                
     212               0 :             $line = trim($line);                                                                                                          
     213               0 :             if ($line == '') continue;                                                                                                    
     214                 :                                                                                                                                           
     215               0 :             $words = explode(' ', $line, 3);                                                                                              
     216                 :                                                                                                                                           
     217               0 :             switch ($words[0]) {                                                                                                          
     218               0 :             case 'TABLE':                                                                                                                 
     219               0 :                 $table = $words[1];                                                                                                       
     220               0 :                 break;                                                                                                                    
     221                 :                                                                                                                                           
     222               0 :             case 'PK':                                                                                                                    
     223               0 :                 $dest_tables[$table]['PK'] = $words[1];                                                                                   
     224               0 :                 break;                                                                                                                    
     225                 :                                                                                                                                           
     226               0 :             default:                                                                                                                      
     227               0 :                 $col = array();                                                                                                           
     228               0 :                 $col['Type'] = $words[1];                                                                                                 
     229                 :                                                                                                                                           
     230               0 :                 $col['NotNull'] = 0;                                                                                                      
     231               0 :                 if (isset($words[2])) {                                                                                                   
     232               0 :                     if ($words[2] == 'notnull') $col['NotNull'] = 1;                                                                      
     233               0 :                     if ($words[2] == 'null') $col['NotNull'] = 0;                                                                         
     234               0 :                 }                                                                                                                         
     235                 :                                                                                                                                           
     236               0 :                 $dest_tables[$table]['Columns'][$words[0]] = $col;                                                                        
     237               0 :                 break;                                                                                                                    
     238               0 :             }                                                                                                                             
     239               0 :         }                                                                                                                                 
     240                 :                                                                                                                                           
     241                 :                                                                                                                                           
     242               0 :         $curr_tables = array ();                                                                                                          
     243                 :                                                                                                                                           
     244               0 :         $table_names = $this->get_table_list();                                                                                           
     245               0 :         foreach ($table_names as $table_name) {                                                                                           
     246               0 :             $curr_tables[$table_name] = array();                                                                                          
     247                 :                                                                                                                                           
     248               0 :             $colres = $this->get_column_details($table_name);                                                                             
     249                 :                                                                                                                                           
     250               0 :             foreach ($colres as $colrow) {                                                                                                
     251               0 :                 $colrow['Type'] = strtolower($colrow['Type']);                                                                            
     252                 :                                                                                                                                           
     253               0 :                 if ($colrow['Key'] == 'PRI') {                                                                                            
     254               0 :                     $curr_tables[$table_name]['PK'] = $colrow['Field'];                                                                   
     255               0 :                 }                                                                                                                         
     256               0 :                 unset ($colrow['Key']);                                                                                                   
     257                 :                                                                                                                                           
     258               0 :                 $curr_tables[$table_name]['Columns'][$colrow['Field']] = $colrow;                                                         
     259               0 :             }                                                                                                                             
     260               0 :         }                                                                                                                                 
     261                 :                                                                                                                                           
     262                 :                                                                                                                                           
     263                 :                                                                                                                                           
     264               0 :         foreach ($dest_tables as $table_name => $dest_table) {                                                                            
     265               0 :             $curr_table = @$curr_tables[$table_name];                                                                                     
     266                 :                                                                                                                                           
     267               0 :             if ($curr_table === null) {                                                                                                   
     268                 :                 // Create the table if it does not yet exist.                                                                             
     269               0 :                 echo "Create table {$table_name}.\n";                                                                                     
     270                 :                                                                                                                                           
     271               0 :                 $this->create_table($table_name, $dest_table);                                                                            
     272                 :                                                                                                                                           
     273                 :                                                                                                                                           
     274               0 :             } else {                                                                                                                      
     275               0 :                 echo "Altering table {$table_name}\n";                                                                                    
     276                 :                                                                                                                                           
     277                 :                 // Update PK                                                                                                              
     278               0 :                 if ($curr_table['PK'] != $dest_table['PK']) {                                                                             
     279               0 :                     echo "  Change primary key from {$curr_table['PK']} to {$dest_table['PK']}\n";                                        
     280                 :                     /* not yet supported */                                                                                               
     281               0 :                 }                                                                                                                         
     282                 :                                                                                                                                           
     283                 :                 // Update columns                                                                                                         
     284               0 :                 foreach ($dest_table['Columns'] as $column_name => $dest_column) {                                                        
     285               0 :                     $curr_column = $curr_table['Columns'][$column_name];                                                                  
     286                 :                                                                                                                                           
     287               0 :                     $dest_sql = $this->get_sql_type($dest_column['Type']);                                                                
     288               0 :                     if ($dest_column['NotNull']) $dest_sql .= ' not null';                                                                
     289                 :                                                                                                                                           
     290               0 :                     if ($curr_column == null) {                                                                                           
     291               0 :                         echo "  Create column {$column_name}. New def: '{$dest_sql}'\n";                                                  
     292                 :                                                                                                                                           
     293               0 :                         $q = "ALTER TABLE {$table_name} ADD COLUMN {$column_name} {$dest_sql}";                                           
     294               0 :                         echo "    <b>Query: {$q}</b>\n";                                                                                  
     295                 :                                                                                                                                           
     296               0 :                         $res = $this->query ($q);                                                                                         
     297               0 :                         if ($res) echo '    Affected rows: ', $this->affected_rows($res), "\n";                                           
     298                 :                                                                                                                                           
     299                 :                                                                                                                                           
     300               0 :                     } else {                                                                                                              
     301               0 :                         $curr_sql = $this->get_sql_type($curr_column['Type']);                                                            
     302               0 :                         if ($curr_column['NotNull']) $curr_sql .= ' not null';                                                            
     303                 :                                                                                                                                           
     304               0 :                         if ($curr_sql != $dest_sql) {                                                                                     
     305               0 :                             echo "  Update col {$column_name}. Old def: '{$curr_sql}' New def: '{$dest_sql}'\n";                          
     306                 :                                                                                                                                           
     307               0 :                             $q = $this->get_alter_column_query ($table_name, $column_name, $curr_column['Type'], $curr_column['NotNull']);
     308               0 :                             echo "    <b>Query: {$q}</b>\n";                                                                              
     309                 :                                                                                                                                           
     310               0 :                             $res = $this->query ($q);                                                                                     
     311               0 :                             if ($res) echo '    Affected rows: ', $this->affected_rows($res), "\n";                                       
     312                 :                                                                                                                                           
     313               0 :                         } else {                                                                                                          
     314               0 :                             echo "  Column {$column_name} does not need to be changed\n";                                                 
     315                 :                         }                                                                                                                 
     316                 :                     }                                                                                                                     
     317                 :                                                                                                                                           
     318               0 :                 }                                                                                                                         
     319                 :             }                                                                                                                             
     320                 :                                                                                                                                           
     321               0 :             echo "\n";                                                                                                                    
     322               0 :         }                                                                                                                                 
     323               0 :     }                                                                                                                                     
     324                 :                                                                                                                                           
     325                 :                                                                                                                                           
     326                 :     /**                                                                                                                                   
     327                 :      * Adds a @since version to from a {@link CodeParserItem} to the internal list                                                        
     328                 :      * This list is used to fill a table with all of the versions of the program in existance                                             
     329                 :      **/                                                                                                                                  
     330                 :     static function addSinceVersion(CodeParserItem $parser_item, $parent)                                                                 
     331                 :     {                                                                                                                                     
     332               0 :         if ($parser_item->since == '') return;                                                                                            
     333                 :                                                                                                                                           
     334               0 :         if (! in_array($parser_item->since, self::$since_versions)) {                                                                     
     335               0 :             self::$since_versions[] = $parser_item->since;                                                                                
     336               0 :         }                                                                                                                                 
     337               0 :     }                                                                                                                                     
     338                 :                                                                                                                                           
     339                 :                                                                                                                                           
     340                 :     /**                                                                                                                                   
     341                 :      * Gets the database id of a record for a specific @since version                                                                     
     342                 :      **/                                                                                                                                  
     343                 :     private function getSinceVersionId($since_version)                                                                                    
     344                 :     {                                                                                                                                     
     345               0 :         $res = array_search($since_version, self::$since_versions);                                                                       
     346               0 :         if ($res === false) return null;                                                                                                  
     347               0 :         return $res + 1;                                                                                                                  
     348                 :     }                                                                                                                                     
     349                 :                                                                                                                                           
     350                 :                                                                                                                                           
     351                 :     /**                                                                                                                                   
     352                 :      * Does the actual outputting of the file objects (and theihttps://www.nationalcrimecheck.com.au/r sub-objects) to the database       
     353                 :      *                                                                                                                                    
     354                 :      * @param array $files The file objects to save to the database                                                                       
     355                 :      * @param Config $config The project config                                                                                           
     356                 :      *                                                                                                                                    
     357                 :      * @table insert projects The main project record                                                                                     
     358                 :      * @table insert packages All of the packages used by this project                                                                    
     359                 :      * @table insert versions All of the project versions documented                                                                      
     360                 :      * @table insert files All of the files                                                                                               
     361                 :      * @table insert documents All of the documents                                                                                       
     362                 :      **/                                                                                                                                  
     363                 :     public function output($files, Config $config)                                                                                        
     364                 :     {                                                                                                                                     
     365               0 :         $res = $this->connect();                                                                                                          
     366               0 :         if (! $res) {                                                                                                                     
     367               0 :             echo "<p>Unable to connect to database!";                                                                                     
     368               0 :             return false;                                                                                                                 
     369                 :         }                                                                                                                                 
     370                 :                                                                                                                                           
     371                 :         // Get existing or create new project                                                                                             
     372               0 :         $code = $this->sql_safen($config->getProjectCode());                                                                              
     373               0 :         $res = $this->query("SELECT id FROM projects WHERE code = {$code}");                                                              
     374               0 :         $row = $this->fetch_assoc($res);                                                                                                  
     375               0 :         if ($row) {                                                                                                                       
     376                 :             // Update project details                                                                                                     
     377               0 :             $project_id = $row['id'];                                                                                                     
     378               0 :             $update_data = array();                                                                                                       
     379               0 :             $update_data['name'] = $this->sql_safen($config->getProjectName());                                                           
     380               0 :             $update_data['license'] = $this->sql_safen($config->getLicenseText());                                                        
     381               0 :             $update_data['dategenerated'] = $this->sql_safen(date('Y-m-d h:i a'));                                                        
     382               0 :             $this->do_update('projects', $update_data, array('id' => $project_id));                                                       
     383                 :                                                                                                                                           
     384               0 :         } else {                                                                                                                          
     385                 :             // Insert new project                                                                                                         
     386               0 :             $insert_data = array();                                                                                                       
     387               0 :             $insert_data['name'] = $this->sql_safen($config->getProjectName());                                                           
     388               0 :             $insert_data['code'] = $this->sql_safen($config->getProjectCode());                                                           
     389               0 :             $insert_data['license'] = $this->sql_safen($config->getLicenseText());                                                        
     390               0 :             $insert_data['dategenerated'] = $this->sql_safen(date('Y-m-d h:i a'));                                                        
     391               0 :             $this->do_insert('projects', $insert_data);                                                                                   
     392               0 :             $project_id = $this->insert_id();                                                                                             
     393                 :         }                                                                                                                                 
     394                 :                                                                                                                                           
     395                 :         // Include project id in all inserts                                                                                              
     396               0 :         $this->extra_insert_data = array(                                                                                                 
     397               0 :             'projectid' => $project_id,                                                                                                   
     398                 :         );                                                                                                                                
     399                 :                                                                                                                                           
     400                 :         // Only delete data from this project                                                                                             
     401               0 :         $this->query("DELETE FROM namespaces WHERE projectid = {$project_id}");                                                           
     402               0 :         $this->query("DELETE FROM files WHERE projectid = {$project_id}");                                                                
     403               0 :         $this->query("DELETE FROM functions WHERE projectid = {$project_id}");                                                            
     404               0 :         $this->query("DELETE FROM arguments WHERE projectid = {$project_id}");                                                            
     405               0 :         $this->query("DELETE FROM classes WHERE projectid = {$project_id}");                                                              
     406               0 :         $this->query("DELETE FROM class_implements WHERE projectid = {$project_id}");                                                     
     407               0 :         $this->query("DELETE FROM interfaces WHERE projectid = {$project_id}");                                                           
     408               0 :         $this->query("DELETE FROM variables WHERE projectid = {$project_id}");                                                            
     409               0 :         $this->query("DELETE FROM constants WHERE projectid = {$project_id}");                                                            
     410               0 :         $this->query("DELETE FROM item_authors WHERE projectid = {$project_id}");                                                         
     411               0 :         $this->query("DELETE FROM item_tables WHERE projectid = {$project_id}");                                                          
     412               0 :         $this->query("DELETE FROM documents WHERE projectid = {$project_id}");                                                            
     413               0 :         $this->query("DELETE FROM versions WHERE projectid = {$project_id}");                                                             
     414               0 :         $this->query("DELETE FROM item_see WHERE projectid = {$project_id}");                                                             
     415               0 :         $this->query("DELETE FROM enumerations WHERE projectid = {$project_id}");                                                         
     416               0 :         $this->query("DELETE FROM item_info_tags WHERE projectid = {$project_id}");                                                       
     417                 :                                                                                                                                           
     418               0 :         $namespaces = array();                                                                                                            
     419               0 :         foreach ($files as $file) {                                                                                                       
     420               0 :             if (empty($file->namespace)) continue;                                                                                        
     421                 :                                                                                                                                           
     422               0 :             $parent_id = 0;                                                                                                               
     423               0 :             $components = array();                                                                                                        
     424               0 :             foreach ($file->namespace as $ns) {                                                                                           
     425               0 :                 $components[] = $ns;                                                                                                      
     426               0 :                 $full_namespace = implode('\\', $components);                                                                             
     427                 :                                                                                                                                                           
     428               0 :                 if (!isset($namespaces[$full_namespace])) {                                                                               
     429               0 :                     $insert_data = array();                                                                                               
     430               0 :                     $insert_data['name'] = $this->sql_safen($full_namespace);                                                             
     431               0 :                     $insert_data['parentid'] = $parent_id;                                                                                
     432               0 :                     $this->do_insert('namespaces', $insert_data);                                                                         
     433               0 :                     $namespaces[$full_namespace] = $this->insert_id();                                                                    
     434               0 :                 }                                                                                                                         
     435                 :                                                                                                                                                           
     436               0 :                 $parent_id = $namespaces[$full_namespace];                                                                                
     437               0 :             }                                                                                                                             
     438               0 :         }                                                                                                                                 
     439                 :                                                                                                                                           
     440                 :         // Determine the versions that are available                                                                                      
     441               0 :         self::$since_versions = array();                                                                                                  
     442               0 :         foreach ($files as $item) {                                                                                                       
     443               0 :             if ($item instanceof ParserFile) {                                                                                            
     444               0 :                 $item->treeWalk(array('DatabaseOutputter', 'addSinceVersion'));                                                           
     445               0 :             }                                                                                                                             
     446               0 :         }                                                                                                                                 
     447                 :                                                                                                                                           
     448                 :         // Sorts the versions array                                                                                                       
     449               0 :         natsort(self::$since_versions);                                                                                                   
     450               0 :         self::$since_versions = array_reverse(self::$since_versions);                                                                     
     451                 :                                                                                                                                           
     452                 :         // And add them to the table                                                                                                      
     453               0 :         foreach (self::$since_versions as $version) {                                                                                     
     454               0 :             $insert_data = array();                                                                                                       
     455               0 :             $insert_data['name'] = $this->sql_safen($version);                                                                            
     456               0 :             $this->do_insert('versions', $insert_data);                                                                                   
     457               0 :         }                                                                                                                                 
     458                 :                                                                                                                                           
     459                 :         // go through all the files                                                                                                       
     460               0 :         foreach ($files as $item) {                                                                                                       
     461               0 :             if ($item instanceof ParserFile) {                                                                                            
     462               0 :                 if ($item->namespace) {                                                                                                   
     463               0 :                     $file_namespace = $namespaces[implode('\\', $item->namespace)];                                                       
     464               0 :                 } else {                                                                                                                  
     465               0 :                     $file_namespace = 0;                                                                                                  
     466                 :                 }                                                                                                                         
     467                 :                                                                                                                                           
     468               0 :                 $insert_data = array();                                                                                                   
     469               0 :                 $insert_data['name'] = $this->sql_safen($item->name);                                                                     
     470               0 :                 $insert_data['description'] = $this->sql_safen($item->description);                                                       
     471               0 :                 $insert_data['source'] = $this->sql_safen($item->source);                                                                 
     472               0 :                 $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($item->since));                                       
     473               0 :                 $insert_data['namespaceid'] = $this->sql_safen($file_namespace);                                                          
     474                 :                                                                                                                                           
     475               0 :                 $this->do_insert('files', $insert_data);                                                                                  
     476               0 :                 $file_id = $this->insert_id ();                                                                                           
     477                 :                                                                                                                                           
     478                 :                 // this files functions                                                                                                   
     479               0 :                 foreach ($item->functions as $function) {                                                                                 
     480               0 :                     $this->save_function($function, $file_id, null, null, $file_namespace);                                               
     481               0 :                 }                                                                                                                         
     482                 :                                                                                                                                           
     483                 :                 // this files classes                                                                                                     
     484               0 :                 foreach ($item->classes as $class) {                                                                                      
     485               0 :                     if ($class instanceof ParserClass) {                                                                                  
     486               0 :                         $this->save_class($class, $file_id, $file_namespace);                                                             
     487               0 :                     } else if ($class instanceof ParserInterface) {                                                                       
     488               0 :                         $this->save_interface($class, $file_id, $file_namespace);                                                         
     489               0 :                     }                                                                                                                     
     490               0 :                 }                                                                                                                         
     491                 :                                                                                                                                           
     492                 :                 // this files constants                                                                                                   
     493               0 :                 foreach ($item->constants as $constant) {                                                                                 
     494               0 :                     $this->save_constant($constant, $file_id);                                                                            
     495               0 :                 }                                                                                                                         
     496                 :                                                                                                                                           
     497                 :                 // this files enums                                                                                                       
     498               0 :                 foreach ($item->enumerations as $enumeration) {                                                                           
     499               0 :                     $this->save_enumeration($enumeration, $file_id);                                                                      
     500               0 :                 }                                                                                                                         
     501                 :                                                                                                                                           
     502                 :                 // Common items                                                                                                           
     503               0 :                 $this->save_author_items (LINK_TYPE_FILE, $file_id, $item->authors);                                                      
     504               0 :                 $this->save_table_items (LINK_TYPE_FILE, $file_id, $item->tables);                                                        
     505               0 :                 $this->save_see_items (LINK_TYPE_FILE, $file_id, $item->see);                                                             
     506               0 :                 $this->save_info_tag_items (LINK_TYPE_FILE, $file_id, $item->info_tags);                                                  
     507                 :                                                                                                                                           
     508                 :                                                                                                                                           
     509               0 :             } else if ($item instanceof ParserDocument) {                                                                                 
     510                 :                 // Inserts a document                                                                                                     
     511               0 :                 $insert_data = array();                                                                                                   
     512               0 :                 $insert_data['name'] = $this->sql_safen($item->name);                                                                     
     513               0 :                 $insert_data['description'] = $this->sql_safen($item->description);                                                       
     514                 :                                                                                                                                           
     515               0 :                 $this->do_insert('documents', $insert_data);                                                                              
     516                 :                                                                                                                                           
     517                 :                                                                                                                                           
     518               0 :             }                                                                                                                             
     519               0 :         }                                                                                                                                 
     520                 :                                                                                                                                           
     521                 :         //$this->commit_transaction();                                                                                                    
     522                 :                                                                                                                                           
     523               0 :         return true;                                                                                                                      
     524                 :     }                                                                                                                                     
     525                 :                                                                                                                                           
     526                 :                                                                                                                                           
     527                 :     /**                                                                                                                                   
     528                 :      * Saves a function to the database                                                                                                   
     529                 :      *                                                                                                                                    
     530                 :      * @table insert functions Adds the function details                                                                                  
     531                 :      * @table insert arguments Adds the arguments for this function                                                                       
     532                 :      **/                                                                                                                                  
     533                 :     private function save_function($function, $file_id, $class_id, $interface_id, $file_namespace)                                        
     534                 :     {                                                                                                                                     
     535                 :         // Ignore closures                                                                                                                
     536               0 :         if ($function->name == null) return;                                                                                              
     537                 :                                                                                                                                           
     538                 :         // prepare data for inserting                                                                                                     
     539               0 :         $insert_data = array();                                                                                                           
     540               0 :         $insert_data['static'] = 0;                                                                                                       
     541               0 :         $insert_data['final'] = 0;                                                                                                        
     542               0 :         $insert_data['abstract'] = 0;                                                                                                     
     543               0 :         $insert_data['name'] = $this->sql_safen($function->name);                                                                         
     544               0 :         $insert_data['description'] = $this->sql_safen($function->description);                                                           
     545               0 :         $insert_data['fileid'] = $file_id;                                                                                                
     546               0 :         $insert_data['linenum'] = $this->sql_safen($function->linenum);                                                                   
     547               0 :         $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($function->since));                                           
     548               0 :         $insert_data['namespaceid'] = $this->sql_safen($file_namespace);                                                                  
     549                 :                                                                                                                                           
     550                 :         // Class-specific details                                                                                                         
     551               0 :         if ($class_id != null) {                                                                                                          
     552               0 :             $insert_data['classid'] = $class_id;                                                                                          
     553               0 :             $insert_data['visibility'] = $this->sql_safen($function->visibility);                                                         
     554                 :                                                                                                                                           
     555                 :             // Interface-specific details                                                                                                 
     556               0 :         } else if ($interface_id != null) {                                                                                               
     557               0 :             $insert_data['interfaceid'] = $interface_id;                                                                                  
     558               0 :             $insert_data['visibility'] = $this->sql_safen($function->visibility);                                                         
     559               0 :         }                                                                                                                                 
     560                 :                                                                                                                                           
     561               0 :         if ($function->static) $insert_data['static'] = 1;                                                                                
     562               0 :         if ($function->final) $insert_data['final'] = 1;                                                                                  
     563                 :                                                                                                                                           
     564                 :         // build arguments string                                                                                                         
     565               0 :         if (count($function->args) > 0) {                                                                                                 
     566               0 :             $args = array();                                                                                                              
     567               0 :             foreach ($function->args as $arg) {                                                                                           
     568               0 :                 if ($arg->type != null) {                                                                                                 
     569               0 :                     $args[] = $arg->type . ' ' . $arg->name;                                                                              
     570               0 :                 } else {                                                                                                                  
     571               0 :                     $args[] = $arg->name;                                                                                                 
     572                 :                 }                                                                                                                         
     573               0 :             }                                                                                                                             
     574               0 :             $insert_data['arguments'] = $this->sql_safen(implode(', ', $args));                                                           
     575                 :                                                                                                                                           
     576               0 :         } else {                                                                                                                          
     577               0 :             $insert_data['arguments'] = "''";                                                                                             
     578                 :         }                                                                                                                                 
     579                 :                                                                                                                                           
     580                 :         // build query from prepared data                                                                                                 
     581               0 :         $this->do_insert('functions', $insert_data);                                                                                      
     582               0 :         $function_id = $this->insert_id ();                                                                                               
     583                 :                                                                                                                                           
     584                 :                                                                                                                                           
     585                 :         // Insert common items                                                                                                            
     586               0 :         $this->save_author_items (LINK_TYPE_FUNCTION, $function_id, $function->authors);                                                  
     587               0 :         $this->save_table_items (LINK_TYPE_FUNCTION, $function_id, $function->tables);                                                    
     588               0 :         $this->save_see_items (LINK_TYPE_FUNCTION, $function_id, $function->see);                                                         
     589               0 :         $this->save_info_tag_items (LINK_TYPE_FUNCTION, $function_id, $function->info_tags);                                              
     590                 :                                                                                                                                           
     591                 :         // insert arguments                                                                                                               
     592               0 :         $args = array();                                                                                                                  
     593               0 :         foreach ($function->args as $arg) {                                                                                               
     594               0 :             $insert_data = array();                                                                                                       
     595               0 :             $insert_data['name'] = $this->sql_safen($arg->name);                                                                          
     596               0 :             $insert_data['type'] = $this->sql_safen($arg->type);                                                                          
     597               0 :             $insert_data['defaultvalue'] = $this->sql_safen($arg->default);                                                               
     598               0 :             $insert_data['description'] = $this->sql_safen($arg->description);                                                            
     599               0 :             $insert_data['functionid'] = $this->sql_safen($function_id);                                                                  
     600               0 :             $args[] = $insert_data;                                                                                                       
     601               0 :         }                                                                                                                                 
     602               0 :         $this->do_multiple_insert('arguments', $args);                                                                                    
     603                 :                                                                                                                                           
     604                 :         // insert throws                                                                                                                  
     605               0 :         $throws = array();                                                                                                                
     606               0 :         foreach ($function->throws as $arg) {                                                                                             
     607               0 :             $insert_data = array();                                                                                                       
     608               0 :             $insert_data['exception'] = $this->sql_safen($arg->exception);                                                                
     609               0 :             $insert_data['description'] = $this->sql_safen($arg->description);                                                            
     610               0 :             $insert_data['functionid'] = $this->sql_safen($function_id);                                                                  
     611               0 :             $throws[] = $insert_data;                                                                                                     
     612               0 :         }                                                                                                                                 
     613               0 :         $this->do_multiple_insert('throws', $throws);                                                                                     
     614                 :                                                                                                                                           
     615                 :         // insert return values                                                                                                           
     616               0 :         $returns = array();                                                                                                               
     617               0 :         foreach ($function->returns as $ret) {                                                                                            
     618               0 :             $insert_data = array();                                                                                                       
     619               0 :             $insert_data['type'] = $this->sql_safen($ret->type);                                                                          
     620               0 :             $insert_data['description'] = $this->sql_safen($ret->description);                                                            
     621               0 :             $insert_data['functionid'] = $this->sql_safen($function_id);                                                                  
     622               0 :             $returns[] = $insert_data;                                                                                                    
     623               0 :         }                                                                                                                                 
     624               0 :         $this->do_multiple_insert('returns', $returns);                                                                                   
     625               0 :     }                                                                                                                                     
     626                 :                                                                                                                                           
     627                 :                                                                                                                                           
     628                 :     /**                                                                                                                                   
     629                 :      * Saves a class to the database                                                                                                      
     630                 :      *                                                                                                                                    
     631                 :      * @table insert classes Adds the class information for this class                                                                    
     632                 :      * @table insert class_implements Adds the interfaces that this class extends                                                         
     633                 :      **/                                                                                                                                  
     634                 :     private function save_class($class, $file_id, $file_namespace)                                                                        
     635                 :     {                                                                                                                                     
     636                 :         // prepare the data for inserting                                                                                                 
     637               0 :         $insert_data = array();                                                                                                           
     638               0 :         $insert_data['abstract'] = 0;                                                                                                     
     639               0 :         $insert_data['final'] = 0;                                                                                                        
     640               0 :         $insert_data['name'] = $this->sql_safen($class->name);                                                                            
     641               0 :         $insert_data['description'] = $this->sql_safen($class->description);                                                              
     642               0 :         $insert_data['extends'] = $this->sql_safen($class->extends);                                                                      
     643               0 :         $insert_data['visibility'] = $this->sql_safen($class->visibility);                                                                
     644               0 :         $insert_data['fileid'] = $file_id;                                                                                                
     645               0 :         $insert_data['linenum'] = $this->sql_safen($class->linenum);                                                                      
     646               0 :         $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($class->since));                                              
     647               0 :         $insert_data['namespaceid'] = $this->sql_safen($file_namespace);                                                                  
     648                 :                                                                                                                                           
     649               0 :         if ($class->abstract) $insert_data['abstract'] = 1;                                                                               
     650               0 :         if ($class->final) $insert_data['final'] = 1;                                                                                     
     651                 :                                                                                                                                           
     652                 :         // Build and process query from prepared data                                                                                     
     653               0 :         $this->do_insert('classes', $insert_data);                                                                                        
     654               0 :         $class_id = $this->insert_id ();                                                                                                  
     655                 :                                                                                                                                           
     656                 :         // process implements                                                                                                             
     657               0 :         foreach ($class->implements as $implements) {                                                                                     
     658               0 :             $insert_data = array();                                                                                                       
     659               0 :             $insert_data['classid'] = $class_id;                                                                                          
     660               0 :             $insert_data['name'] = $this->sql_safen($implements);                                                                         
     661                 :                                                                                                                                           
     662               0 :             $this->do_insert('class_implements', $insert_data);                                                                           
     663               0 :         }                                                                                                                                 
     664                 :                                                                                                                                           
     665                 :                                                                                                                                           
     666                 :         // process functions                                                                                                              
     667               0 :         foreach ($class->functions as $function) {                                                                                        
     668               0 :             $this->save_function($function, $file_id, $class_id, null, $file_namespace);                                                  
     669               0 :         }                                                                                                                                 
     670                 :                                                                                                                                           
     671                 :         // process variables                                                                                                              
     672               0 :         foreach ($class->variables as $variable) {                                                                                        
     673               0 :             $this->save_variable($variable, $class_id);                                                                                   
     674               0 :         }                                                                                                                                 
     675                 :                                                                                                                                           
     676                 :         // Insert common items                                                                                                            
     677               0 :         $this->save_author_items (LINK_TYPE_CLASS, $class_id, $class->authors);                                                           
     678               0 :         $this->save_table_items (LINK_TYPE_CLASS, $class_id, $class->tables);                                                             
     679               0 :         $this->save_see_items (LINK_TYPE_CLASS, $class_id, $class->see);                                                                  
     680               0 :         $this->save_info_tag_items (LINK_TYPE_CLASS, $class_id, $class->info_tags);                                                       
     681               0 :     }                                                                                                                                     
     682                 :                                                                                                                                           
     683                 :                                                                                                                                           
     684                 :     /**                                                                                                                                   
     685                 :      * Saves an interface to the database                                                                                                 
     686                 :      *                                                                                                                                    
     687                 :      * @table insert interfaces                                                                                                           
     688                 :      **/                                                                                                                                  
     689                 :     private function save_interface($interface, $file_id, $file_namespace)                                                                
     690                 :     {                                                                                                                                     
     691                 :         // prepare the data for inserting                                                                                                 
     692               0 :         $insert_data = array();                                                                                                           
     693               0 :         $insert_data['name'] = $this->sql_safen($interface->name);                                                                        
     694               0 :         $insert_data['description'] = $this->sql_safen($interface->description);                                                          
     695               0 :         $insert_data['extends'] = $this->sql_safen($interface->extends);                                                                  
     696               0 :         $insert_data['visibility'] = $this->sql_safen($interface->visibility);                                                            
     697               0 :         $insert_data['fileid'] = $file_id;                                                                                                
     698               0 :         $insert_data['linenum'] = $this->sql_safen($interface->linenum);                                                                  
     699               0 :         $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($interface->since));                                          
     700               0 :         $insert_data['namespaceid'] = $this->sql_safen($file_namespace);                                                                  
     701                 :                                                                                                                                           
     702                 :         // Build and process query from prepared data                                                                                     
     703               0 :         $this->do_insert('interfaces', $insert_data);                                                                                     
     704               0 :         $interface_id = $this->insert_id ();                                                                                              
     705                 :                                                                                                                                           
     706                 :                                                                                                                                           
     707                 :         // process functions                                                                                                              
     708               0 :         foreach ($interface->functions as $function) {                                                                                    
     709               0 :             $this->save_function ($function, $file_id, null, $interface_id, $file_namespace);                                             
     710               0 :         }                                                                                                                                 
     711                 :                                                                                                                                           
     712                 :         // insert common items                                                                                                            
     713               0 :         $this->save_author_items (LINK_TYPE_INTERFACE, $interface_id, $interface->authors);                                               
     714               0 :         $this->save_see_items (LINK_TYPE_INTERFACE, $interface_id, $interface->see);                                                      
     715               0 :         $this->save_info_tag_items (LINK_TYPE_INTERFACE, $interface_id, $interface->info_tags);                                           
     716               0 :     }                                                                                                                                     
     717                 :                                                                                                                                           
     718                 :                                                                                                                                           
     719                 :     /**                                                                                                                                   
     720                 :      * Saves a variable to the database                                                                                                   
     721                 :      *                                                                                                                                    
     722                 :      * @table insert variables                                                                                                            
     723                 :      **/                                                                                                                                  
     724                 :     private function save_variable($variable, $class_id = null, $interface_id = null)                                                     
     725                 :     {                                                                                                                                     
     726                 :         // prepare data for inserting                                                                                                     
     727               0 :         $insert_data = array();                                                                                                           
     728               0 :         $insert_data['static'] = 0;                                                                                                       
     729               0 :         $insert_data['name'] = $this->sql_safen($variable->name);                                                                         
     730               0 :         $insert_data['description'] = $this->sql_safen($variable->description);                                                           
     731                 :         //$insert_data['visibility'] = $this->sql_safen($variable->visibility);                                                           
     732               0 :         $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($variable->since));                                           
     733                 :                                                                                                                                           
     734                 :                                                                                                                                           
     735                 :         // Class-specific details                                                                                                         
     736               0 :         if ($class_id != null) {                                                                                                          
     737               0 :             $insert_data['classid'] = $class_id;                                                                                          
     738                 :                                                                                                                                           
     739                 :             // Interface-specific details                                                                                                 
     740               0 :         } else if ($interface_id != null) {                                                                                               
     741               0 :             $insert_data['interfaceid'] = $interface_id;                                                                                  
     742               0 :         }                                                                                                                                 
     743                 :                                                                                                                                           
     744               0 :         if ($variable->static) $insert_data['static'] = 1;                                                                                
     745                 :                                                                                                                                           
     746                 :                                                                                                                                           
     747                 :         // Build and process query from prepared data                                                                                     
     748               0 :         $this->do_insert('variables', $insert_data);                                                                                      
     749               0 :         $variable_id = $this->insert_id ();                                                                                               
     750                 :                                                                                                                                           
     751                 :         // insert common items                                                                                                            
     752               0 :         $this->save_author_items (LINK_TYPE_VARIABLE, $variable_id, $variable->authors);                                                  
     753               0 :         $this->save_see_items (LINK_TYPE_VARIABLE, $variable_id, $variable->see);                                                         
     754               0 :         $this->save_info_tag_items (LINK_TYPE_VARIABLE, $variable_id, $variable->info_tags);                                              
     755               0 :     }                                                                                                                                     
     756                 :                                                                                                                                           
     757                 :                                                                                                                                           
     758                 :     /**                                                                                                                                   
     759                 :      * Saves a constant to the database                                                                                                   
     760                 :      *                                                                                                                                    
     761                 :      * @table insert constants                                                                                                            
     762                 :      **/                                                                                                                                  
     763                 :     private function save_constant($constant, $file_id = null, $enumeration_id = null)                                                    
     764                 :     {                                                                                                                                     
     765                 :         // prepare data for inserting                                                                                                     
     766               0 :         $insert_data = array();                                                                                                           
     767               0 :         $insert_data['name'] = $this->sql_safen($constant->name);                                                                         
     768               0 :         $insert_data['value'] = $this->sql_safen($constant->value);                                                                       
     769               0 :         $insert_data['description'] = $this->sql_safen($constant->description);                                                           
     770               0 :         $insert_data['fileid'] = $this->sql_safen($file_id);                                                                              
     771               0 :         $insert_data['linenum'] = $this->sql_safen($constant->linenum);                                                                   
     772               0 :         $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($constant->since));                                           
     773                 :                                                                                                                                           
     774               0 :         if ($enumeration_id != null) {                                                                                                    
     775               0 :             $insert_data['enumerationid'] = $enumeration_id;                                                                              
     776               0 :         }                                                                                                                                 
     777                 :                                                                                                                                           
     778                 :         // Build and process query from prepared data                                                                                     
     779               0 :         $this->do_insert('constants', $insert_data);                                                                                      
     780               0 :         $constant_id = $this->insert_id ();                                                                                               
     781                 :                                                                                                                                           
     782                 :         // insert common items                                                                                                            
     783               0 :         $this->save_author_items (LINK_TYPE_CONSTANT, $constant_id, $constant->authors);                                                  
     784               0 :         $this->save_see_items (LINK_TYPE_CONSTANT, $constant_id, $constant->see);                                                         
     785               0 :         $this->save_info_tag_items (LINK_TYPE_CONSTANT, $constant_id, $constant->info_tags);                                              
     786               0 :     }                                                                                                                                     
     787                 :                                                                                                                                           
     788                 :                                                                                                                                           
     789                 :     /**                                                                                                                                   
     790                 :      * Saves a enumeration to the database                                                                                                
     791                 :      *                                                                                                                                    
     792                 :      * @table insert enumerations                                                                                                         
     793                 :      **/                                                                                                                                  
     794                 :     private function save_enumeration($enumeration, $file_id = null)                                                                      
     795                 :     {                                                                                                                                     
     796                 :         // prepare data for inserting                                                                                                     
     797               0 :         $insert_data = array();                                                                                                           
     798               0 :         $insert_data['name'] = $this->sql_safen($enumeration->name);                                                                      
     799               0 :         $insert_data['description'] = $this->sql_safen($enumeration->description);                                                        
     800               0 :         $insert_data['fileid'] = $this->sql_safen($file_id);                                                                              
     801               0 :         $insert_data['linenum'] = $this->sql_safen($enumeration->linenum);                                                                
     802               0 :         $insert_data['sinceid'] = $this->sql_safen($this->getSinceVersionId($constant->since));                                           
     803               0 :         $insert_data['virtual'] = $this->sql_safen($enumeration->virtual);                                                                
     804                 :                                                                                                                                           
     805                 :         // Build and process query from prepared data                                                                                     
     806               0 :         $this->do_insert('enumerations', $insert_data);                                                                                   
     807               0 :         $enumeration_id = $this->insert_id ();                                                                                            
     808                 :                                                                                                                                           
     809                 :         // insert common items                                                                                                            
     810               0 :         $this->save_author_items (LINK_TYPE_ENUMERATION, $enumeration_id, $enumeration->authors);                                         
     811               0 :         $this->save_see_items (LINK_TYPE_ENUMERATION, $enumeration_id, $enumeration->see);                                                
     812               0 :         $this->save_info_tag_items (LINK_TYPE_ENUMERATION, $enumeration_id, $enumeration->info_tags);                                     
     813                 :                                                                                                                                           
     814                 :         // Save the constants for this enumeration                                                                                        
     815               0 :         foreach ($enumeration->constants as $constant) {                                                                                  
     816               0 :             $this->save_constant ($constant, $file_id, $enumeration_id);                                                                  
     817               0 :         }                                                                                                                                 
     818               0 :     }                                                                                                                                     
     819                 :                                                                                                                                           
     820                 :                                                                                                                                           
     821                 :     /**                                                                                                                                   
     822                 :      * Saves author information about an item                                                                                             
     823                 :      *                                                                                                                                    
     824                 :      * @table insert item_authors                                                                                                         
     825                 :      **/                                                                                                                                  
     826                 :     private function save_author_items($link_type, $link_id, $items)                                                                      
     827                 :     {                                                                                                                                     
     828               0 :         $rows = array();                                                                                                                  
     829               0 :         foreach ($items as $item) {                                                                                                       
     830               0 :             $insert_data = array();                                                                                                       
     831               0 :             $insert_data['linkid'] = $this->sql_safen($link_id);                                                                          
     832               0 :             $insert_data['linktype'] = $this->sql_safen($link_type);                                                                      
     833               0 :             $insert_data['name'] = $this->sql_safen($item->name);                                                                         
     834               0 :             $insert_data['email'] = $this->sql_safen($item->email);                                                                       
     835               0 :             $insert_data['description'] = $this->sql_safen($item->description);                                                           
     836               0 :             $rows[] = $insert_data;                                                                                                       
     837               0 :         }                                                                                                                                 
     838               0 :         $this->do_multiple_insert('item_authors', $rows);                                                                                 
     839               0 :     }                                                                                                                                     
     840                 :                                                                                                                                           
     841                 :                                                                                                                                           
     842                 :     /**                                                                                                                                   
     843                 :      * Saves table usage information about an item                                                                                        
     844                 :      *                                                                                                                                    
     845                 :      * @since 0.2                                                                                                                         
     846                 :      * @table insert item_tables Adds information about the tables that are used by a function, class or file.                            
     847                 :      **/                                                                                                                                  
     848                 :     private function save_table_items($link_type, $link_id, $items)                                                                       
     849                 :     {                                                                                                                                     
     850               0 :         $rows = array();                                                                                                                  
     851               0 :         foreach ($items as $item) {                                                                                                       
     852               0 :             $insert_data = array();                                                                                                       
     853               0 :             $insert_data['linkid'] = $this->sql_safen($link_id);                                                                          
     854               0 :             $insert_data['linktype'] = $this->sql_safen($link_type);                                                                      
     855               0 :             $insert_data['name'] = $this->sql_safen($item->name);                                                                         
     856               0 :             $insert_data['action'] = $this->sql_safen($item->action);                                                                     
     857               0 :             $insert_data['description'] = $this->sql_safen($item->description);                                                           
     858               0 :             $rows[] = $insert_data;                                                                                                       
     859               0 :         }                                                                                                                                 
     860               0 :         $this->do_multiple_insert('item_tables', $rows);                                                                                  
     861               0 :     }                                                                                                                                     
     862                 :                                                                                                                                           
     863                 :                                                                                                                                           
     864                 :     /**                                                                                                                                   
     865                 :      * Saves 'see also' information about an item                                                                                         
     866                 :      *                                                                                                                                    
     867                 :      * @since 0.2                                                                                                                         
     868                 :      * @table insert item_see Adds 'see also' links for a function, class, file, etc.                                                     
     869                 :      **/                                                                                                                                  
     870                 :     private function save_see_items($link_type, $link_id, $items)                                                                         
     871                 :     {                                                                                                                                     
     872               0 :         $rows = array();                                                                                                                  
     873               0 :         foreach ($items as $item) {                                                                                                       
     874               0 :             $insert_data = array();                                                                                                       
     875               0 :             $insert_data['linkid'] = $this->sql_safen($link_id);                                                                          
     876               0 :             $insert_data['linktype'] = $this->sql_safen($link_type);                                                                      
     877               0 :             $insert_data['name'] = $this->sql_safen($item);                                                                               
     878               0 :             $rows[] = $insert_data;                                                                                                       
     879               0 :         }                                                                                                                                 
     880               0 :         $this->do_multiple_insert('item_see', $rows);                                                                                     
     881               0 :     }                                                                                                                                     
     882                 :                                                                                                                                           
     883                 :                                                                                                                                           
     884                 :     /**                                                                                                                                   
     885                 :      * Saves info tags for an item                                                                                                        
     886                 :      *                                                                                                                                    
     887                 :      * @since 0.3                                                                                                                         
     888                 :      * @table insert item_info_tags Adds info tags links for a function, class, file, etc.                                                
     889                 :      **/                                                                                                                                  
     890                 :     private function save_info_tag_items($link_type, $link_id, $items)                                                                    
     891                 :     {                                                                                                                                     
     892               0 :         $rows = array();                                                                                                                  
     893               0 :         foreach ($items as $item) {                                                                                                       
     894               0 :             $insert_data = array();                                                                                                       
     895               0 :             $insert_data['linkid'] = $this->sql_safen($link_id);                                                                          
     896               0 :             $insert_data['linktype'] = $this->sql_safen($link_type);                                                                      
     897               0 :             $insert_data['name'] = $this->sql_safen($item);                                                                               
     898               0 :             $rows[] = $insert_data;                                                                                                       
     899               0 :         }                                                                                                                                 
     900               0 :         $this->do_multiple_insert('item_info_tags', $rows);                                                                               
     901               0 :     }                                                                                                                                     
     902                 :                                                                                                                                           
     903                 :                                                                                                                                           
     904                 : }                                                                                                                                         
     905                 :                                                                                                                                           
     906                 :                                                                                                                                           
     907                 : ?>                                                                                                                                        

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.