libraries/import.lib.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Library that provides common import functions that are used by import plugins
   5  *
   6  * @version $Id$
   7  * @package phpMyAdmin
   8  */
   9 if (! defined('PHPMYADMIN')) {
  10     exit;
  11 }
  12
  13 /**
  14  * We need to know something about user
  15  */
  16 require_once './libraries/check_user_privileges.lib.php';
  17
  18 /**
  19  * We do this check, DROP DATABASE does not need to be confirmed elsewhere
  20  */
  21 define('PMA_CHK_DROP', 1);
  22
  23 /**
  24  *  Check whether timeout is getting close
  25  *
  26  *  @return boolean true if timeout is close
  27  *  @access public
  28  */
  29 function PMA_checkTimeout()
  30 {
  31     global $timestamp, $maximum_time, $timeout_passed;
  32     if ($maximum_time == 0) {
  33         return FALSE;
  34     } elseif ($timeout_passed) {
  35         return TRUE;
  36     /* 5 in next row might be too much */
  37     } elseif ((time() - $timestamp) > ($maximum_time - 5)) {
  38         $timeout_passed = TRUE;
  39         return TRUE;
  40     } else {
  41         return FALSE;
  42     }
  43 }
  44
  45 /**
  46  *  Detects what compression filse uses
  47  *
  48  *  @param  string filename to check
  49  *  @return string MIME type of compression, none for none
  50  *  @access public
  51  */
  52 function PMA_detectCompression($filepath)
  53 {
  54     $file = @fopen($filepath, 'rb');
  55     if (!$file) {
  56         return FALSE;
  57     }
  58     $test = fread($file, 4);
  59     $len = strlen($test);
  60     fclose($file);
  61     if ($len >= 2 && $test[0] == chr(31) && $test[1] == chr(139)) {
  62         return 'application/gzip';
  63     }
  64     if ($len >= 3 && substr($test, 0, 3) == 'BZh') {
  65         return 'application/bzip2';
  66     }
  67     if ($len >= 4 && $test == "PK\003\004") {
  68         return 'application/zip';
  69     }
  70     return 'none';
  71 }
  72
  73 /**
  74  * Runs query inside import buffer. This is needed to allow displaying
  75  * of last SELECT, SHOW or HANDLER results and similar nice stuff.
  76  *
  77  * @uses    $GLOBALS['finished'] read and write
  78  * @param  string query to run
  79  * @param  string query to display, this might be commented
  80  * @param  bool   whether to use control user for queries
  81  * @access public
  82  */
  83 function PMA_importRunQuery($sql = '', $full = '', $controluser = false)
  84 {
  85     global $import_run_buffer, $go_sql, $complete_query, $display_query,
  86         $sql_query, $my_die, $error, $reload,
  87         $last_query_with_results,
  88         $skip_queries, $executed_queries, $max_sql_len, $read_multiply,
  89         $cfg, $sql_query_disabled, $db, $run_query, $is_superuser;
  90     $read_multiply = 1;
  91     if (isset($import_run_buffer)) {
  92         // Should we skip something?
  93         if ($skip_queries > 0) {
  94             $skip_queries--;
  95         } else {
  96             if (!empty($import_run_buffer['sql']) && trim($import_run_buffer['sql']) != '') {
  97                 $max_sql_len = max($max_sql_len, strlen($import_run_buffer['sql']));
  98                 if (!$sql_query_disabled) {
  99                     $sql_query .= $import_run_buffer['full'];
 100                 }
 101                 if (!$cfg['AllowUserDropDatabase']
 102                  && !$is_superuser
 103                  && preg_match('@^[[:space:]]*DROP[[:space:]]+(IF EXISTS[[:space:]]+)?DATABASE @i', $import_run_buffer['sql'])) {
 104                     $GLOBALS['message'] = PMA_Message::error('strNoDropDatabases');
 105                     $error = TRUE;
 106                 } else {
 107                     $executed_queries++;
 108                     if ($run_query && $GLOBALS['finished'] && empty($sql) && !$error && (
 109                             (!empty($import_run_buffer['sql']) && preg_match('/^[\s]*(SELECT|SHOW|HANDLER)/i', $import_run_buffer['sql'])) ||
 110                             ($executed_queries == 1)
 111                             )) {
 112                         $go_sql = TRUE;
 113                         if (!$sql_query_disabled) {
 114                             $complete_query = $sql_query;
 115                             $display_query = $sql_query;
 116                         } else {
 117                             $complete_query = '';
 118                             $display_query = '';
 119                         }
 120                         $sql_query = $import_run_buffer['sql'];
 121                         // If a 'USE <db>' SQL-clause was found, set our current $db to the new one
 122                         list($db, $reload) = PMA_lookForUse($import_run_buffer['sql'], $db, $reload);
 123                     } elseif ($run_query) {
 124                         if ($controluser) {
 125                             $result = PMA_query_as_controluser($import_run_buffer['sql']);
 126                         } else {
 127                             $result = PMA_DBI_try_query($import_run_buffer['sql']);
 128                         }
 129                         $msg = '# ';
 130                         if ($result === FALSE) { // execution failed
 131                             if (!isset($my_die)) {
 132                                 $my_die = array();
 133                             }
 134                             $my_die[] = array('sql' => $import_run_buffer['full'], 'error' => PMA_DBI_getError());
 135
 136                             if ($cfg['VerboseMultiSubmit']) {
 137                                 $msg .= $GLOBALS['strError'];
 138                             }
 139
 140                             if (!$cfg['IgnoreMultiSubmitErrors']) {
 141                                 $error = TRUE;
 142                                 return;
 143                             }
 144                         } elseif ($cfg['VerboseMultiSubmit']) {
 145                             $a_num_rows = (int)@PMA_DBI_num_rows($result);
 146                             $a_aff_rows = (int)@PMA_DBI_affected_rows();
 147                             if ($a_num_rows > 0) {
 148                                 $msg .= $GLOBALS['strRows'] . ': ' . $a_num_rows;
 149                                 $last_query_with_results = $import_run_buffer['sql'];
 150                             } elseif ($a_aff_rows > 0) {
 151                                 $msg .= sprintf($GLOBALS['strRowsAffected'], $a_aff_rows);
 152                             } else {
 153                                 $msg .= $GLOBALS['strEmptyResultSet'];
 154                             }
 155                         }
 156                         if (!$sql_query_disabled) {
 157                             $sql_query .= $msg . "\n";
 158                         }
 159
 160                         // If a 'USE <db>' SQL-clause was found and the query succeeded, set our current $db to the new one
 161                         if ($result != FALSE) {
 162                             list($db, $reload) = PMA_lookForUse($import_run_buffer['sql'], $db, $reload);
 163                         }
 164
 165                         if ($result != FALSE && preg_match('@^[\s]*(DROP|CREATE)[\s]+(IF EXISTS[[:space:]]+)?(TABLE|DATABASE)[[:space:]]+(.+)@im', $import_run_buffer['sql'])) {
 166                             $reload = TRUE;
 167                         }
 168                     } // end run query
 169                 } // end if not DROP DATABASE
 170             } // end non empty query
 171             elseif (!empty($import_run_buffer['full'])) {
 172                 if ($go_sql) {
 173                     $complete_query .= $import_run_buffer['full'];
 174                     $display_query .= $import_run_buffer['full'];
 175                 } else {
 176                     if (!$sql_query_disabled) {
 177                         $sql_query .= $import_run_buffer['full'];
 178                     }
 179                 }
 180             }
 181             // check length of query unless we decided to pass it to sql.php
 182             // (if $run_query is false, we are just displaying so show
 183             // the complete query in the textarea)
 184             if (! $go_sql && $run_query) {
 185                 if ($cfg['VerboseMultiSubmit'] && ! empty($sql_query)) {
 186                     if (strlen($sql_query) > 50000 || $executed_queries > 50 || $max_sql_len > 1000) {
 187                         $sql_query = '';
 188                         $sql_query_disabled = TRUE;
 189                     }
 190                 } else {
 191                     if (strlen($sql_query) > 10000 || $executed_queries > 10 || $max_sql_len > 500) {
 192                         $sql_query = '';
 193                         $sql_query_disabled = TRUE;
 194                     }
 195                 }
 196             }
 197         } // end do query (no skip)
 198     } // end buffer exists
 199
 200     // Do we have something to push into buffer?
 201     if (!empty($sql) || !empty($full)) {
 202         $import_run_buffer = array('sql' => $sql, 'full' => $full);
 203     } else {
 204         unset($GLOBALS['import_run_buffer']);
 205     }
 206 }
 207
 208 /**
 209  * Looks for the presence of USE to possibly change current db
 210  *
 211  * @param  string buffer to examine
 212  * @param  string current db
 213  * @param  boolean reload
 214  * @return array (current or new db, whether to reload)
 215  * @access public
 216  */
 217 function PMA_lookForUse($buffer, $db, $reload)
 218 {
 219     if (preg_match('@^[\s]*USE[[:space:]]*([\S]+)@i', $buffer, $match)) {
 220         $db = trim($match[1]);
 221         $db = trim($db,';'); // for example, USE abc;
 222         $reload = TRUE;
 223     }
 224     return(array($db, $reload));
 225 }
 226
 227
 228 /**
 229  * Returns next part of imported file/buffer
 230  *
 231  * @uses    $GLOBALS['offset'] read and write
 232  * @uses    $GLOBALS['import_file'] read only
 233  * @uses    $GLOBALS['import_text'] read and write
 234  * @uses    $GLOBALS['finished'] read and write
 235  * @uses    $GLOBALS['read_limit'] read only
 236  * @param  integer size of buffer to read (this is maximal size
 237  *                  function will return)
 238  * @return string part of file/buffer
 239  * @access public
 240  */
 241 function PMA_importGetNextChunk($size = 32768)
 242 {
 243     global $compression, $import_handle, $charset_conversion, $charset_of_file,
 244         $charset, $read_multiply;
 245
 246     // Add some progression while reading large amount of data
 247     if ($read_multiply <= 8) {
 248         $size *= $read_multiply;
 249     } else {
 250         $size *= 8;
 251     }
 252     $read_multiply++;
 253
 254     // We can not read too much
 255     if ($size > $GLOBALS['read_limit']) {
 256         $size = $GLOBALS['read_limit'];
 257     }
 258
 259     if (PMA_checkTimeout()) {
 260         return FALSE;
 261     }
 262     if ($GLOBALS['finished']) {
 263         return TRUE;
 264     }
 265
 266     if ($GLOBALS['import_file'] == 'none') {
 267         // Well this is not yet supported and tested, but should return content of textarea
 268         if (strlen($GLOBALS['import_text']) < $size) {
 269             $GLOBALS['finished'] = TRUE;
 270             return $GLOBALS['import_text'];
 271         } else {
 272             $r = substr($GLOBALS['import_text'], 0, $size);
 273             $GLOBALS['offset'] += $size;
 274             $GLOBALS['import_text'] = substr($GLOBALS['import_text'], $size);
 275             return $r;
 276         }
 277     }
 278
 279     switch ($compression) {
 280         case 'application/bzip2':
 281             $result = bzread($import_handle, $size);
 282             $GLOBALS['finished'] = feof($import_handle);
 283             break;
 284         case 'application/gzip':
 285             $result = gzread($import_handle, $size);
 286             $GLOBALS['finished'] = feof($import_handle);
 287             break;
 288         case 'application/zip':
 289             $result = substr($GLOBALS['import_text'], 0, $size);
 290             $GLOBALS['import_text'] = substr($GLOBALS['import_text'], $size);
 291             $GLOBALS['finished'] = empty($GLOBALS['import_text']);
 292             break;
 293         case 'none':
 294             $result = fread($import_handle, $size);
 295             $GLOBALS['finished'] = feof($import_handle);
 296             break;
 297     }
 298     $GLOBALS['offset'] += $size;
 299
 300     if ($charset_conversion) {
 301         return PMA_convert_string($charset_of_file, $charset, $result);
 302     } else {
 303         /**
 304          * Skip possible byte order marks (I do not think we need more
 305          * charsets, but feel free to add more, you can use wikipedia for
 306          * reference: <http://en.wikipedia.org/wiki/Byte_Order_Mark>)
 307          *
 308          * @todo BOM could be used for charset autodetection
 309          */
 310         if ($GLOBALS['offset'] == $size) {
 311             // UTF-8
 312             if (strncmp($result, "\xEF\xBB\xBF", 3) == 0) {
 313                 $result = substr($result, 3);
 314             // UTF-16 BE, LE
 315             } elseif (strncmp($result, "\xFE\xFF", 2) == 0 || strncmp($result, "\xFF\xFE", 2) == 0) {
 316                 $result = substr($result, 2);
 317             }
 318         }
 319         return $result;
 320     }
 321 }
 322
 323 /**
 324  * Returns the "Excel" column name (i.e. 1 = "A", 26 = "Z", 27 = "AA", etc.)
 325  *
 326  * This functions uses recursion to build the Excel column name.
 327  *
 328  * The column number (1-26) is converted to the responding ASCII character (A-Z) and returned.
 329  *
 330  * If the column number is bigger than 26 (= num of letters in alfabet),
 331  * an extra character needs to be added. To find this extra character, the number is divided by 26
 332  * and this value is passed to another instance of the same function (hence recursion).
 333  * In that new instance the number is evaluated again, and if it is still bigger than 26, it is divided again
 334  * and passed to another instance of the same function. This continues until the number is smaller than 26.
 335  * Then the last called function returns the corresponding ASCII character to the function that called it.
 336  * Each time a called function ends an extra character is added to the column name.
 337  * When the first function is reached, the last character is addded and the complete column name is returned.
 338  *
 339  * @access  public
 340  *
 341  * @uses    chr()
 342  * @param   int $num
 343  * @return  string The column's "Excel" name
 344  */
 345 function PMA_getColumnAlphaName($num)
 346 {
 347         $A = 65; // ASCII value for capital "A"
 348         $col_name = "";
 349
 350         if ($num > 26) {
 351                 $div = (int)($num / 26);
 352                 $remain = (int)($num % 26);
 353
 354                 // subtract 1 of divided value in case the modulus is 0,
 355                 // this is necessary because A-Z has no 'zero'
 356                 if ($remain == 0) {
 357                         $div--;
 358                 }
 359
 360                 // recursive function call
 361                 $col_name = PMA_getColumnAlphaName($div);
 362                 // use modulus as new column number
 363                 $num = $remain;
 364         }
 365
 366         if ($num == 0) {
 367                 // use 'Z' if column number is 0,
 368                 // this is necessary because A-Z has no 'zero'
 369                 $col_name .= chr(($A + 26) - 1);
 370         } else {
 371                 // convert column number to ASCII character
 372                 $col_name .= chr(($A + $num) - 1);
 373         }
 374
 375         return $col_name;
 376 }
 377
 378 /**
 379  * Returns the column number based on the Excel name.
 380  * So "A" = 1, "Z" = 26, "AA" = 27, etc.
 381  *
 382  * Basicly this is a base26 (A-Z) to base10 (0-9) conversion.
 383  * It iterates through all characters in the column name and
 384  * calculates the corresponding value, based on character value
 385  * (A = 1, ..., Z = 26) and position in the string.
 386  *
 387  * @access  public
 388  *
 389  * @uses    strtoupper()
 390  * @uses    strlen()
 391  * @uses    ord()
 392  * @param   string $name (i.e. "A", or "BC", etc.)
 393  * @return  int The column number
 394  */
 395 function PMA_getColumnNumberFromName($name) {
 396     if (!empty($name)) {
 397         $name = strtoupper($name);
 398         $num_chars = strlen($name);
 399         $column_number = 0;
 400         for ($i = 0; $i < $num_chars; ++$i) {
 401                 // read string from back to front
 402                 $char_pos = ($num_chars - 1) - $i;
 403
 404                 // convert capital character to ASCII value
 405                 // and subtract 64 to get corresponding decimal value
 406                 // ASCII value of "A" is 65, "B" is 66, etc.
 407                 // Decimal equivalent of "A" is 1, "B" is 2, etc.
 408                 $number = (ord($name[$char_pos]) - 64);
 409
 410                 // base26 to base10 conversion : multiply each number
 411                 // with corresponding value of the position, in this case
 412                 // $i=0 : 1; $i=1 : 26; $i=2 : 676; ...
 413                 $column_number += $number * pow(26,$i);
 414         }
 415         return $column_number;
 416     } else {
 417         return 0;
 418     }
 419 }
 420
 421 /**
 422  * Constants definitions
 423  */
 424
 425 /* MySQL type defs */
 426 define("NONE",      0);
 427 define("VARCHAR",   1);
 428 define("INT",       2);
 429 define("DECIMAL",   3);
 430 define("BIGINT",    4);
 431
 432 /* Decimal size defs */
 433 define("M",         0);
 434 define("D",         1);
 435 define("FULL",      2);
 436
 437 /* Table array defs */
 438 define("TBL_NAME",  0);
 439 define("COL_NAMES", 1);
 440 define("ROWS",      2);
 441
 442 /* Analysis array defs */
 443 define("TYPES",     0);
 444 define("SIZES",     1);
 445
 446 /**
 447  * Obtains the precision (total # of digits) from a size of type decimal
 448  *
 449  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 450  *
 451  * @access  public
 452  *
 453  * @uses    substr()
 454  * @uses    strpos()
 455  * @param   string $last_cumulative_size
 456  * @return  int Precision of the given decimal size notation
 457  */
 458 function PMA_getM($last_cumulative_size) {
 459     return (int)substr($last_cumulative_size, 0, strpos($last_cumulative_size, ","));
 460 }
 461
 462 /**
 463  * Obtains the scale (# of digits to the right of the decimal point) from a size of type decimal
 464  *
 465  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 466  *
 467  * @access  public
 468  *
 469  * @uses    substr()
 470  * @uses    strpos()
 471  * @uses    strlen()
 472  * @param   string $last_cumulative_size
 473  * @return  int Scale of the given decimal size notation
 474  */
 475 function PMA_getD($last_cumulative_size) {
 476         return (int)substr($last_cumulative_size, (strpos($last_cumulative_size, ",") + 1), (strlen($last_cumulative_size) - strpos($last_cumulative_size, ",")));
 477 }
 478
 479 /**
 480  * Obtains the decimal size of a given cell
 481  *
 482  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 483  *
 484  * @access  public
 485  *
 486  * @uses    strlen()
 487  * @uses    strpos()
 488  * @param   string &$cell
 489  * @return  array Contains the precision, scale, and full size representation of the given decimal cell
 490  */
 491 function PMA_getDecimalSize(&$cell) {
 492     $curr_size = strlen((string)$cell);
 493     $decPos = strpos($cell, ".");
 494     $decPrecision = ($curr_size - 1) - $decPos;
 495
 496     $m = $curr_size - 1;
 497     $d = $decPrecision;
 498
 499     return array($m, $d, ($m . "," . $d));
 500 }
 501
 502 /**
 503  * Obtains the size of the given cell
 504  *
 505  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 506  *
 507  * @todo    Handle the error cases more elegantly
 508  *
 509  * @access  public
 510  *
 511  * @uses    M
 512  * @uses    D
 513  * @uses    FULL
 514  * @uses    VARCHAR
 515  * @uses    DECIMAL
 516  * @uses    BIGINT
 517  * @uses    INT
 518  * @uses    NONE
 519  * @uses    strcmp()
 520  * @uses    strlen()
 521  * @uses    PMA_getM()
 522  * @uses    PMA_getD()
 523  * @uses    PMA_getDecimalSize()
 524  * @param   string $last_cumulative_size    Last cumulative column size
 525  * @param   int    $last_cumulative_type    Last cumulative column type  (NONE or VARCHAR or DECIMAL or INT or BIGINT)
 526  * @param   int    $curr_type               Type of the current cell     (NONE or VARCHAR or DECIMAL or INT or BIGINT)
 527  * @param   string &$cell                   The current cell
 528  * @return  string                          Size of the given cell in the type-appropriate format
 529  */
 530 function PMA_detectSize($last_cumulative_size, $last_cumulative_type, $curr_type, &$cell) {
 531         $curr_size = strlen((string)$cell);
 532
 533     /**
 534      * If the cell is NULL, don't treat it as a varchar
 535      */
 536     if (! strcmp('NULL', $cell)) {
 537         return $last_cumulative_size;
 538     }
 539     /**
 540      * What to do if the current cell is of type VARCHAR
 541      */
 542         elseif ($curr_type == VARCHAR) {
 543         /**
 544          * The last cumulative type was VARCHAR
 545          */
 546                 if ($last_cumulative_type == VARCHAR) {
 547                         if ($curr_size >= $last_cumulative_size) {
 548                                 return $curr_size;
 549             } else {
 550                                 return $last_cumulative_size;
 551             }
 552                 }
 553         /**
 554          * The last cumulative type was DECIMAL
 555          */
 556         elseif ($last_cumulative_type == DECIMAL) {
 557             $oldM = PMA_getM($last_cumulative_size);
 558
 559             if ($curr_size >= $oldM) {
 560                 return $curr_size;
 561             } else {
 562                 return $oldM;
 563             }
 564                 }
 565         /**
 566          * The last cumulative type was BIGINT or INT
 567          */
 568         elseif ($last_cumulative_type == BIGINT || $last_cumulative_type == INT) {
 569             if ($curr_size >= $last_cumulative_size) {
 570                 return $curr_size;
 571             } else {
 572                 return $last_cumulative_size;
 573             }
 574                 }
 575         /**
 576          * This is the first row to be analyzed
 577          */
 578         elseif (! isset($last_cumulative_type) || $last_cumulative_type == NONE) {
 579             return $curr_size;
 580         }
 581         /**
 582          * An error has DEFINITELY occurred
 583          */
 584         else {
 585             /**
 586              * TODO: Handle this MUCH more elegantly
 587              */
 588
 589             return -1;
 590         }
 591         }
 592     /**
 593      * What to do if the current cell is of type DECIMAL
 594      */
 595     elseif ($curr_type == DECIMAL) {
 596         /**
 597          * The last cumulative type was VARCHAR
 598          */
 599                 if ($last_cumulative_type == VARCHAR) {
 600             /* Convert $last_cumulative_size from varchar to decimal format */
 601                     $size = PMA_getDecimalSize($cell);
 602
 603                     if ($size[M] >= $last_cumulative_size) {
 604                         return $size[M];
 605             } else {
 606                     return $last_cumulative_size;
 607             }
 608                 }
 609         /**
 610          * The last cumulative type was DECIMAL
 611          */
 612         elseif ($last_cumulative_type == DECIMAL) {
 613                     $size = PMA_getDecimalSize($cell);
 614
 615                     $oldM = PMA_getM($last_cumulative_size);
 616                     $oldD = PMA_getD($last_cumulative_size);
 617
 618                     /* New val if M or D is greater than current largest */
 619                     if ($size[M] > $oldM || $size[D] > $oldD) {
 620                             /* Take the largest of both types */
 621                             return (string)((($size[M] > $oldM) ? $size[M] : $oldM) . "," . (($size[D] > $oldD) ? $size[D] : $oldD));
 622             } else {
 623                             return $last_cumulative_size;
 624             }
 625                 }
 626         /**
 627          * The last cumulative type was BIGINT or INT
 628          */
 629         elseif ($last_cumulative_type == BIGINT || $last_cumulative_type == INT) {
 630                     /* Convert $last_cumulative_size from int to decimal format */
 631                     $size = PMA_getDecimalSize($cell);
 632
 633                     if ($size[M] >= $last_cumulative_size) {
 634                         return $size[FULL];
 635             } else {
 636                     return ($last_cumulative_size.",".$size[D]);
 637             }
 638                 }
 639         /**
 640          * This is the first row to be analyzed
 641          */
 642         elseif (! isset($last_cumulative_type) || $last_cumulative_type == NONE) {
 643             /* First row of the column */
 644                     $size = PMA_getDecimalSize($cell);
 645
 646                     return $size[FULL];
 647                 }
 648         /**
 649          * An error has DEFINITELY occurred
 650          */
 651                 else {
 652             /**
 653              * TODO: Handle this MUCH more elegantly
 654              */
 655
 656             return -1;
 657         }
 658         }
 659     /**
 660      * What to do if the current cell is of type BIGINT or INT
 661      */
 662     elseif ($curr_type == BIGINT || $curr_type == INT) {
 663         /**
 664          * The last cumulative type was VARCHAR
 665          */
 666                 if ($last_cumulative_type == VARCHAR) {
 667                     if ($curr_size >= $last_cumulative_size) {
 668                         return $curr_size;
 669             } else {
 670                     return $last_cumulative_size;
 671             }
 672                 }
 673         /**
 674          * The last cumulative type was DECIMAL
 675          */
 676         elseif ($last_cumulative_type == DECIMAL) {
 677             $oldM = PMA_getM($last_cumulative_size);
 678                     $oldD = PMA_getD($last_cumulative_size);
 679                     $oldInt = $oldM - $oldD;
 680                     $newInt = strlen((string)$cell);
 681
 682                     /* See which has the larger integer length */
 683                     if ($oldInt >= $newInt) {
 684                             /* Use old decimal size */
 685                             return $last_cumulative_size;
 686             } else {
 687                             /* Use $newInt + $oldD as new M */
 688                             return (($newInt + $oldD) . "," . $oldD);
 689             }
 690             }
 691         /**
 692          * The last cumulative type was BIGINT or INT
 693          */
 694         elseif ($last_cumulative_type == BIGINT || $last_cumulative_type == INT) {
 695                     if ($curr_size >= $last_cumulative_size) {
 696                         return $curr_size;
 697             } else {
 698                     return $last_cumulative_size;
 699             }
 700                 }
 701         /**
 702          * This is the first row to be analyzed
 703          */
 704         elseif (!isset($last_cumulative_type) || $last_cumulative_type == NONE) {
 705             return $curr_size;
 706         }
 707         /**
 708          * An error has DEFINITELY occurred
 709          */
 710                 else {
 711             /**
 712              * TODO: Handle this MUCH more elegantly
 713              */
 714
 715             return -1;
 716         }
 717         }
 718     /**
 719      * An error has DEFINITELY occurred
 720      */
 721         else {
 722         /**
 723          * TODO: Handle this MUCH more elegantly
 724          */
 725
 726         return -1;
 727     }
 728 }
 729
 730 /**
 731  * Determines what MySQL type a cell is
 732  *
 733  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 734  *
 735  * @access  public
 736  *
 737  * @uses    DECIMAL
 738  * @uses    BIGINT
 739  * @uses    INT
 740  * @uses    VARCHAR
 741  * @uses    NONE
 742  * @uses    is_numeric()
 743  * @uses    strcmp()
 744  * @uses    strpos()
 745  * @uses    substr_count()
 746  * @param   int    $last_cumulative_type  Last cumulative column type  (VARCHAR or INT or BIGINT or DECIMAL or NONE)
 747  * @param   string &$cell                 String representation of the cell for which a best-fit type is to be determined
 748  * @return  int                           The MySQL type representation (VARCHAR or INT or BIGINT or DECIMAL or NONE)
 749  */
 750 function PMA_detectType($last_cumulative_type, &$cell) {
 751     /**
 752      * If numeric, determine if decimal, int or bigint
 753      * Else, we call it varchar for simplicity
 754      */
 755
 756     if (! strcmp('NULL', $cell)) {
 757         if ($last_cumulative_type === NULL || $last_cumulative_type == NONE) {
 758             return NONE;
 759         } else {
 760             return $last_cumulative_type;
 761         }
 762     } elseif (is_numeric($cell)) {
 763         if ($cell == (string)(float)$cell && strpos($cell, ".") !== false && substr_count($cell, ".") == 1) {
 764             return DECIMAL;
 765         } else {
 766                 if (abs($cell) > 2147483647) {
 767                         return BIGINT;
 768                 } else {
 769                         return INT;
 770                 }
 771         }
 772     } else {
 773         return VARCHAR;
 774     }
 775 }
 776
 777 /**
 778  * Determines if the column types are int, decimal, or string
 779  *
 780  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 781  *
 782  * @link http://wiki.phpmyadmin.net/pma/Devel:Import
 783  *
 784  * @todo    Handle the error case more elegantly
 785  *
 786  * @access  public
 787  *
 788  * @uses    TBL_NAME
 789  * @uses    COL_NAMES
 790  * @uses    ROWS
 791  * @uses    VARCHAR
 792  * @uses    DECIMAL
 793  * @uses    BIGINT
 794  * @uses    INT
 795  * @uses    NONE
 796  * @uses    count()
 797  * @uses    is_array()
 798  * @uses    PMA_detectType()
 799  * @uses    PMA_detectSize()
 800  * @param   &$table  array(string $table_name, array $col_names, array $rows)
 801  * @return  array    array(array $types, array $sizes)
 802  */
 803 function PMA_analyzeTable(&$table) {
 804         /* Get number of rows in table */
 805         $numRows = count($table[ROWS]);
 806         /* Get number of columns */
 807         $numCols = count($table[COL_NAMES]);
 808         /* Current type for each column */
 809         $types = array();
 810         $sizes = array();
 811
 812         /* Initialize $sizes to all 0's */
 813         for ($i = 0; $i < $numCols; ++$i) {
 814                 $sizes[$i] = 0;
 815         }
 816
 817     /* Initialize $types to NONE */
 818     for ($i = 0; $i < $numCols; ++$i) {
 819         $types[$i] = NONE;
 820     }
 821
 822         /* Temp vars */
 823         $curr_type = NONE;
 824         $curr_size = 0;
 825
 826         /* If the passed array is not of the correct form, do not process it */
 827         if (is_array($table) && ! is_array($table[TBL_NAME]) && is_array($table[COL_NAMES]) && is_array($table[ROWS])) {
 828                 /* Analyze each column */
 829                 for ($i = 0; $i < $numCols; ++$i) {
 830                         /* Analyze the column in each row */
 831                         for ($j = 0; $j < $numRows; ++$j) {
 832                                 /* Determine type of the current cell */
 833                                 $curr_type = PMA_detectType($types[$i], $table[ROWS][$j][$i]);
 834                                 /* Determine size of the current cell */
 835                                 $sizes[$i] = PMA_detectSize($sizes[$i], $types[$i], $curr_type, $table[ROWS][$j][$i]);
 836
 837                                 /**
 838                                  * If a type for this column has already been declared,
 839                                  * only alter it if it was a number and a varchar was found
 840                                  */
 841                                 if ($curr_type != NONE) {
 842                                         if ($curr_type == VARCHAR) {
 843                                                 $types[$i] = VARCHAR;
 844                                         } else if ($curr_type == DECIMAL) {
 845                                                 if ($types[$i] != VARCHAR) {
 846                                                         $types[$i] = DECIMAL;
 847                                                 }
 848                                         } else if ($curr_type == BIGINT) {
 849                                                 if ($types[$i] != VARCHAR && $types[$i] != DECIMAL) {
 850                                                         $types[$i] = BIGINT;
 851                                                 }
 852                                         } else if ($curr_type == INT) {
 853                                                 if ($types[$i] != VARCHAR && $types[$i] != DECIMAL && $types[$i] != BIGINT) {
 854                                                         $types[$i] = INT;
 855                                                 }
 856                                         }
 857                                 }
 858                         }
 859                 }
 860
 861         /* Check to ensure that all types are valid */
 862         $len = count($types);
 863         for ($n = 0; $n < $len; ++$n) {
 864             if (! strcmp(NONE, $types[$n])) {
 865                 $types[$n] = VARCHAR;
 866                 $sizes[$n] = '10';
 867             }
 868         }
 869
 870                 return array($types, $sizes);
 871         }
 872         else
 873         {
 874         /**
 875          * TODO: Handle this better
 876          */
 877
 878                 return false;
 879         }
 880 }
 881
 882 /* Needed to quell the beast that is PMA_Message */
 883 $import_notice = NULL;
 884
 885 /**
 886  * Builds and executes SQL statements to create the database and tables
 887  * as necessary, as well as insert all the data.
 888  *
 889  * @author  Derek Schaefer (derek.schaefer@gmail.com)
 890  *
 891  * @link http://wiki.phpmyadmin.net/pma/Devel:Import
 892  *
 893  * @access  public
 894  *
 895  * @uses    TBL_NAME
 896  * @uses    COL_NAMES
 897  * @uses    ROWS
 898  * @uses    TYPES
 899  * @uses    SIZES
 900  * @uses    strcmp()
 901  * @uses    count()
 902  * @uses    preg_match()
 903  * @uses    preg_replace()
 904  * @uses    PMA_isView()
 905  * @uses    PMA_backquote()
 906  * @uses    PMA_importRunQuery()
 907  * @uses    PMA_generate_common_url()
 908  * @uses    PMA_Message::notice()
 909  * @param   string  $db_name                 Name of the database
 910  * @param   array   &$tables                 Array of tables for the specified database
 911  * @param   array   &$analyses = NULL        Analyses of the tables
 912  * @param   array   &$additional_sql = NULL  Additional SQL statements to be executed
 913  * @param   array   $options = NULL          Associative array of options
 914  * @return  void
 915  */
 916 function PMA_buildSQL($db_name, &$tables, &$analyses = NULL, &$additional_sql = NULL, $options = NULL) {
 917     /* Take care of the options */
 918     if (isset($options['db_collation'])) {
 919         $collation = $options['db_collation'];
 920     } else {
 921         $collation = "utf8_general_ci";
 922     }
 923
 924     if (isset($options['db_charset'])) {
 925         $charset = $options['db_charset'];
 926     } else {
 927         $charset = "utf8";
 928     }
 929
 930     if (isset($options['create_db'])) {
 931         $create_db = $options['create_db'];
 932     } else {
 933         $create_db = true;
 934     }
 935
 936     /* Create SQL code to handle the database */
 937     $sql = array();
 938
 939     if ($create_db) {
 940         $sql[] = "CREATE DATABASE IF NOT EXISTS " . PMA_backquote($db_name) . " DEFAULT CHARACTER SET " . $charset . " COLLATE " . $collation;
 941     }
 942
 943     /**
 944      * The calling plug-in should include this statement, if necessary, in the $additional_sql parameter
 945      *
 946      * $sql[] = "USE " . PMA_backquote($db_name);
 947      */
 948
 949     /* Execute the SQL statements create above */
 950     $sql_len = count($sql);
 951     for ($i = 0; $i < $sql_len; ++$i) {
 952         PMA_importRunQuery($sql[$i], $sql[$i]);
 953     }
 954
 955     /* No longer needed */
 956     unset($sql);
 957
 958     /* Run the $additional_sql statements supplied by the caller plug-in */
 959     if ($additional_sql != NULL) {
 960         /* Clean the SQL first */
 961         $additional_sql_len = count($additional_sql);
 962
 963         /**
 964          * Only match tables for now, because CREATE IF NOT EXISTS
 965          * syntax is lacking or nonexisting for views, triggers,
 966          * functions, and procedures.
 967          *
 968          * See: http://bugs.mysql.com/bug.php?id=15287
 969          *
 970          * To the best of my knowledge this is still an issue.
 971          *
 972          * $pattern = 'CREATE (TABLE|VIEW|TRIGGER|FUNCTION|PROCEDURE)';
 973          */
 974         $pattern = '/CREATE .*(TABLE)/';
 975         $replacement = 'CREATE \\1 IF NOT EXISTS';
 976
 977         /* Change CREATE statements to CREATE IF NOT EXISTS to support inserting into existing structures */
 978         for ($i = 0; $i < $additional_sql_len; ++$i) {
 979             $additional_sql[$i] = preg_replace($pattern, $replacement, $additional_sql[$i]);
 980             /* Execute the resulting statements */
 981             PMA_importRunQuery($additional_sql[$i], $additional_sql[$i]);
 982         }
 983     }
 984
 985     if ($analyses != NULL) {
 986         $type_array = array(NONE => "NULL", VARCHAR => "varchar", INT => "int", DECIMAL => "decimal", BIGINT => "bigint");
 987
 988         /* TODO: Do more checking here to make sure they really are matched */
 989         if (count($tables) != count($analyses)) {
 990             exit();
 991         }
 992
 993         /* Create SQL code to create the tables */
 994         $tempSQLStr = "";
 995         $num_tables = count($tables);
 996         for ($i = 0; $i < $num_tables; ++$i) {
 997             $num_cols = count($tables[$i][COL_NAMES]);
 998             $tempSQLStr = "CREATE TABLE IF NOT EXISTS " . PMA_backquote($db_name) . '.' . PMA_backquote($tables[$i][TBL_NAME]) . " (";
 999             for ($j = 0; $j < $num_cols; ++$j) {
1000                 $size = $analyses[$i][SIZES][$j];
1001                 if ((int)$size == 0) {
1002                     $size = 10;
1003                 }
1004
1005                 $tempSQLStr .= PMA_backquote($tables[$i][COL_NAMES][$j]) . " " . $type_array[$analyses[$i][TYPES][$j]] . "(" . $size . ")";
1006
1007                 if ($j != (count($tables[$i][COL_NAMES]) - 1)) {
1008                     $tempSQLStr .= ", ";
1009                 }
1010             }
1011             $tempSQLStr .= ") ENGINE=MyISAM DEFAULT CHARACTER SET " . $charset . " COLLATE " . $collation . ";";
1012
1013             /**
1014              * Each SQL statement is executed immediately
1015              * after it is formed so that we don't have
1016              * to store them in a (possibly large) buffer
1017              */
1018             PMA_importRunQuery($tempSQLStr, $tempSQLStr);
1019         }
1020     }
1021
1022     /**
1023      * Create the SQL statements to insert all the data
1024      *
1025      * Only one insert query is formed for each table
1026      */
1027         $tempSQLStr = "";
1028         $col_count = 0;
1029     $num_tables = count($tables);
1030         for ($i = 0; $i < $num_tables; ++$i) {
1031         $num_cols = count($tables[$i][COL_NAMES]);
1032         $num_rows = count($tables[$i][ROWS]);
1033
1034         $tempSQLStr = "INSERT INTO " . PMA_backquote($db_name) . '.' . PMA_backquote($tables[$i][TBL_NAME]) . " (";
1035
1036         for ($m = 0; $m < $num_cols; ++$m) {
1037             $tempSQLStr .= PMA_backquote($tables[$i][COL_NAMES][$m]);
1038
1039             if ($m != ($num_cols - 1)) {
1040                 $tempSQLStr .= ", ";
1041             }
1042         }
1043
1044         $tempSQLStr .= ") VALUES ";
1045
1046                 for ($j = 0; $j < $num_rows; ++$j) {
1047             $tempSQLStr .= "(";
1048
1049                         for ($k = 0; $k < $num_cols; ++$k) {
1050                 if ($analyses != NULL) {
1051                     $is_varchar = ($analyses[$i][TYPES][$col_count] === VARCHAR);
1052                 } else {
1053                     $is_varchar = !is_numeric($tables[$i][ROWS][$j][$k]);
1054                 }
1055
1056                 /* Don't put quotes around NULL fields */
1057                 if (! strcmp($tables[$i][ROWS][$j][$k], 'NULL')) {
1058                     $is_varchar = false;
1059                 }
1060
1061                 $tempSQLStr .= (($is_varchar) ? "'" : "");
1062                                 $tempSQLStr .= PMA_sqlAddslashes((string)$tables[$i][ROWS][$j][$k]);
1063                                 $tempSQLStr .= (($is_varchar) ? "'" : "");
1064
1065                                 if ($k != ($num_cols - 1)) {
1066                                         $tempSQLStr .= ", ";
1067                 }
1068
1069                                 if ($col_count == ($num_cols - 1)) {
1070                                         $col_count = 0;
1071                                 } else {
1072                                         $col_count++;
1073                 }
1074
1075                 /* Delete the cell after we are done with it */
1076                 unset($tables[$i][ROWS][$j][$k]);
1077                         }
1078
1079             $tempSQLStr .= ")";
1080
1081             if ($j != ($num_rows - 1)) {
1082                 $tempSQLStr .= ",\n ";
1083             }
1084
1085                         $col_count = 0;
1086             /* Delete the row after we are done with it */
1087             unset($tables[$i][ROWS][$j]);
1088                 }
1089
1090         $tempSQLStr .= ";";
1091
1092         /**
1093          * Each SQL statement is executed immediately
1094          * after it is formed so that we don't have
1095          * to store them in a (possibly large) buffer
1096          */
1097         PMA_importRunQuery($tempSQLStr, $tempSQLStr);
1098         }
1099
1100     /* No longer needed */
1101     unset($tempSQLStr);
1102
1103     /**
1104      * A work in progress
1105      */
1106
1107     /* Add the viewable structures from $additional_sql to $tables so they are also displayed */
1108
1109     $view_pattern = '@VIEW `[^`]+`\.`([^`]+)@';
1110     $table_pattern = '@CREATE TABLE IF NOT EXISTS `([^`]+)`@';
1111     /* Check a third pattern to make sure its not a "USE `db_name`;" statement */
1112
1113     $regs = array();
1114
1115     $inTables = false;
1116
1117     $additional_sql_len = count($additional_sql);
1118     for ($i = 0; $i < $additional_sql_len; ++$i) {
1119         preg_match($view_pattern, $additional_sql[$i], $regs);
1120
1121         if (count($regs) == 0) {
1122             preg_match($table_pattern, $additional_sql[$i], $regs);
1123         }
1124
1125         if (count($regs)) {
1126             for ($n = 0; $n < $num_tables; ++$n) {
1127                 if (!strcmp($regs[1], $tables[$n][TBL_NAME])) {
1128                     $inTables = true;
1129                     break;
1130                 }
1131             }
1132
1133             if (!$inTables) {
1134                 $tables[] = array(TBL_NAME => $regs[1]);
1135             }
1136         }
1137
1138         /* Reset the array */
1139         $regs = array();
1140         $inTables = false;
1141     }
1142
1143     $params = array('db' => (string)$db_name);
1144     $db_url = 'db_structure.php' . PMA_generate_common_url($params);
1145     $db_ops_url = 'db_operations.php' . PMA_generate_common_url($params);
1146
1147     $message = '<br /><br />';
1148     $message .= '<strong>' . $GLOBALS['strImportNoticePt1'] . '</strong><br />';
1149     $message .= '<ul><li>' . $GLOBALS['strImportNoticePt2'] . '</li>';
1150     $message .= '<li>' . $GLOBALS['strImportNoticePt3'] . '</li>';
1151     $message .= '<li>' . $GLOBALS['strImportNoticePt4'] . '</li>';
1152     $message .= sprintf('<br /><li><a href="%s" title="%s">%s</a> (<a href="%s" title="%s">' . $GLOBALS['strOptions'] . '</a>)</li>',
1153                         $db_url,
1154                         $GLOBALS['strGoToDatabase'] . ': ' . PMA_backquote($db_name),
1155                         $db_name,
1156                         $db_ops_url,
1157                         $GLOBALS['strEdit'] . ' ' . PMA_backquote($db_name) . ' ' . $GLOBALS['strSettings']);
1158
1159     $message .= '<ul>';
1160
1161     unset($params);
1162
1163     $num_tables = count($tables);
1164     for ($i = 0; $i < $num_tables; ++$i)
1165     {
1166         $params = array('db' => (string)$db_name, 'table' => (string)$tables[$i][TBL_NAME]);
1167         $tbl_url = 'sql.php' . PMA_generate_common_url($params);
1168         $tbl_struct_url = 'tbl_structure.php' . PMA_generate_common_url($params);
1169         $tbl_ops_url = 'tbl_operations.php' . PMA_generate_common_url($params);
1170
1171         unset($params);
1172
1173         if (! PMA_isView($db_name, $tables[$i][TBL_NAME])) {
1174             $message .= sprintf('<li><a href="%s" title="%s">%s</a> (<a href="%s" title="%s">' . $GLOBALS['strStructure'] . '</a>) (<a href="%s" title="%s">' . $GLOBALS['strOptions'] . '</a>)</li>',
1175                                 $tbl_url,
1176                                 $GLOBALS['strGoToTable'] . ': ' . PMA_backquote($tables[$i][TBL_NAME]),
1177                                 $tables[$i][TBL_NAME],
1178                                 $tbl_struct_url,
1179                                 PMA_backquote($tables[$i][TBL_NAME]) . ' ' . $GLOBALS['strStructureLC'],
1180                                 $tbl_ops_url,
1181                                 $GLOBALS['strEdit'] . ' ' . PMA_backquote($tables[$i][TBL_NAME]) . ' ' . $GLOBALS['strSettings']);
1182         } else {
1183             $message .= sprintf('<li><a href="%s" title="%s">%s</a></li>',
1184                                 $tbl_url,
1185                                 $GLOBALS['strGoToView'] . ': ' . PMA_backquote($tables[$i][TBL_NAME]),
1186                                 $tables[$i][TBL_NAME]);
1187         }
1188     }
1189
1190     $message .= '</ul></ul>';
1191
1192     global $import_notice;
1193     $import_notice = $message;
1194
1195     unset($tables);
1196 }
1197
1198 ?>