Want more features on Pastebin? Sign Up, it's FREE!
Guest

sqlbuddy fix - export.php.diff

By: a guest on Feb 13th, 2012  |  syntax: PHP  |  size: 29.66 KB  |  views: 103  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. 143a144,145
  2. >            
  3. >             if (is_array($tables) {
  4. 145,470c147,474
  5. <                       foreach ($tables as $t) {
  6. <                              
  7. <                               if ($format == "SQL") {
  8. <                                      
  9. <                                       if ($conn->getAdapter() == "mysql")
  10. <                                               $structureSQL = $conn->query("SHOW FULL FIELDS FROM `$t`");
  11. <                                       else
  12. <                                               $structureSQL = $conn->describeTable($t);
  13. <                                      
  14. <                                       $tableEngine = "";
  15. <                                       $tableCharset = "";
  16. <                                       $autoIncrement = "";
  17. <                                      
  18. <                                       if (isset($exportStructure)) {
  19. <                                              
  20. <                                               if ($conn->isResultSet($structureSQL)) {
  21. <                                                      
  22. <                                                       if ($conn->getAdapter() == "mysql") {
  23. <                                                              
  24. <                                                               $outputBuffer .= "CREATE TABLE `$t` (";
  25. <                                                              
  26. <                                                               $infoSql = $conn->query("SHOW TABLE STATUS LIKE '$t'");
  27. <                                                              
  28. <                                                               if ($conn->isResultSet($infoSql) == 1) {
  29. <                                                                      
  30. <                                                                       $infoRow = $conn->fetchAssoc($infoSql);
  31. <                                                                      
  32. <                                                                       $tableEngine = (array_key_exists("Type", $infoRow)) ? $infoRow['Type'] : $infoRow['Engine'];
  33. <                                                                      
  34. <                                                                       if (array_key_exists('Collation', $infoRow) && isset($collationList)) {
  35. <                                                                               $tableCharset = $collationList[$infoRow['Collation']];
  36. <                                                                       }
  37. <                                                                      
  38. <                                                                       if (array_key_exists('Auto_increment', $infoRow))
  39. <                                                                       {
  40. <                                                                               $autoIncrement = $infoRow['Auto_increment'];
  41. <                                                                       }
  42. <                                                               }
  43. <                                                              
  44. <                                                       } else if ($conn->getAdapter() == "sqlite") {
  45. <                                                              
  46. <                                                               $outputBuffer .= "CREATE TABLE '$t' (";
  47. <                                                       }
  48. <                                                      
  49. <                                                       $first = true;
  50. <                                                      
  51. <                                                       if ($conn->getAdapter() == "mysql") {
  52. <                                                      
  53. <                                                               while ($structureRow = $conn->fetchassoc($structureSQL)) {
  54. <                                                                      
  55. <                                                                       if (!$first)
  56. <                                                                               $outputBuffer .= ",";
  57. <                                                                      
  58. <                                                                       $outputBuffer .= "\r\n   `" . $structureRow['Field'] . "` " . $structureRow['Type'];
  59. <                                                                      
  60. <                                                                       if (isset($collationList) && isset($structureRow['Collation']) && $structureRow['Collation'] != "NULL" && !is_null($structureRow['Collation'])) {
  61. <                                                                               if ($collationList[$structureRow['Collation']] != $tableCharset) {
  62. <                                                                                       $outputBuffer .= " CHARSET " . $collationList[$structureRow['Collation']];
  63. <                                                                               }
  64. <                                                                       }
  65. <                                                                      
  66. <                                                                       if (isset($structureRow['Null']) && $structureRow['Null'] != "YES")
  67. <                                                                               $outputBuffer .= " not null";
  68. <                                                                      
  69. <                                                                       if (isset($structureRow['Default']) && $structureRow['Default'] == "CURRENT_TIMESTAMP") {
  70. <                                                                               $outputBuffer .= " default CURRENT_TIMESTAMP";
  71. <                                                                       } else if (isset($structureRow['Default']) && $structureRow['Default'] != "") {
  72. <                                                                               $outputBuffer .= " default '" . $structureRow['Default'] . "'";
  73. <                                                                       }
  74. <                                                                      
  75. <                                                                       if (isset($structureRow['Extra']) && $structureRow['Extra'] != "")
  76. <                                                                               $outputBuffer .= " " . $structureRow['Extra'];
  77. <                                                                      
  78. <                                                                       $first = false;
  79. <                                                               }
  80. <                                                      
  81. <                                                       } else if ($conn->getAdapter() == "sqlite") {
  82. <                                                              
  83. <                                                               foreach ($structureSQL as $structureRow) {
  84. <                                                                      
  85. <                                                                       if (!$first)
  86. <                                                                               $outputBuffer .= ",";
  87. <                                                                      
  88. <                                                                       $outputBuffer .= "\r\n   " . $structureRow[0] . " " . $structureRow[1];
  89. <                                                                      
  90. <                                                                       $first = false;
  91. <                                                               }
  92. <                                                              
  93. <                                                       }
  94. <                                                      
  95. <                                                       // dont forget about the keys
  96. <                                                       if ($conn->getAdapter() == "mysql") {
  97. <                                                               $keySQL = $conn->query("SHOW INDEX FROM `$t`");
  98. <                                                              
  99. <                                                               if ($conn->isResultSet($keySQL)) {
  100. <                                                                       $currentKey = "";
  101. <                                                                       while ($keyRow = $conn->fetchAssoc($keySQL)) {
  102. <                                                                               // if this is the start of a key
  103. <                                                                               if ($keyRow['Key_name'] != $currentKey) {      
  104. <                                                                                       // finish off the last key first, if necessary
  105. <                                                                                       if ($currentKey != "")
  106. <                                                                                               $outputBuffer .= ")";
  107. <                                                                                      
  108. <                                                                                       if ($keyRow['Key_name'] == "PRIMARY")
  109. <                                                                                               $outputBuffer .= ",\r\n   PRIMARY KEY (";
  110. <                                                                                       elseif ($keyRow['Non_unique'] == "0")
  111. <                                                                                               $outputBuffer .= ",\r\n   UNIQUE KEY (";
  112. <                                                                                       else
  113. <                                                                                               $outputBuffer .= ",\r\n   KEY `" . $keyRow['Key_name'] . "` (";
  114. <                                                                                      
  115. <                                                                                       $outputBuffer .= "`" . $keyRow['Column_name'] . "`";
  116. <                                                                               } else {
  117. <                                                                                       $outputBuffer .= ",`" . $keyRow['Column_name'] . "`";
  118. <                                                                               }
  119. <                                                                              
  120. <                                                                               $currentKey = $keyRow['Key_name'];
  121. <                                                                       }
  122. <                                                                      
  123. <                                                                       if (isset($currentKey) && $currentKey != "")
  124. <                                                                               $outputBuffer .= ")";
  125. <                                                               }
  126. <                                                       }
  127. <                                                      
  128. <                                                       $outputBuffer .= "\r\n)";
  129. <                                                      
  130. <                                                       if ($conn->getAdapter() == "mysql") {
  131. <                                                               if ($tableEngine) {
  132. <                                                                       $outputBuffer .= ' ENGINE=' . $tableEngine;
  133. <                                                               }
  134. <                                                              
  135. <                                                               if ($tableCharset) {
  136. <                                                                       $outputBuffer .= ' DEFAULT CHARSET=' . $tableCharset;
  137. <                                                               }
  138. <                                                              
  139. <                                                               if ($autoIncrement)
  140. <                                                               {
  141. <                                                                       $outputBuffer .= ' AUTO_INCREMENT=' . $autoIncrement;
  142. <                                                               }
  143. <                                                       }
  144. <                                                      
  145. <                                                       $outputBuffer .= ";\r\n\r\n";
  146. <                                               }
  147. <                                       }
  148. <                                      
  149. <                                       if ($conn->getAdapter() == "mysql")
  150. <                                               $structureSQL = $conn->query("SHOW FULL FIELDS FROM `$t`");
  151. <                                       else
  152. <                                               $structureSQL = $conn->describeTable($t);
  153. <                                      
  154. <                                       if (isset($exportData)) {
  155. <                                              
  156. <                                               $columnList = array();
  157. <                                              
  158. <                                               if ($conn->getAdapter() == "mysql") {
  159. <                                                      
  160. <                                                       $dataSQL = $conn->query("SELECT * FROM `$t`");
  161. <                                                      
  162. <                                                       // put the column names in an array
  163. <                                                       if ($conn->isResultSet($structureSQL)) {
  164. <                                                               while ($structureRow = $conn->fetchAssoc($structureSQL)) {
  165. <                                                                       $columnList[] = $structureRow['Field'];
  166. <                                                                       $type[] = $structureRow['Type'];
  167. <                                                               }
  168. <                                                       }
  169. <                                                      
  170. <                                                       $columnImplosion = implode("`, `", $columnList);
  171. <                                                      
  172. <                                                       if ($conn->isResultSet($dataSQL)) {
  173. <                                                              
  174. <                                                               if ($insertType == "COMPACT")
  175. <                                                                       $outputBuffer .= "INSERT INTO `$t` (`$columnImplosion`) VALUES \r\n";
  176. <                                                              
  177. <                                                               $firstLine = true;
  178. <                                                              
  179. <                                                               while ($dataRow = $conn->fetchAssoc($dataSQL)) {
  180. <                                                                      
  181. <                                                                       if ($insertType == "COMPLETE") {
  182. <                                                                               $outputBuffer .= "INSERT INTO `$t` (`$columnImplosion`) VALUES ";
  183. <                                                                       } else {
  184. <                                                                               if (!$firstLine)
  185. <                                                                                       $outputBuffer .= ",\r\n";
  186. <                                                                       }
  187. <                                                                      
  188. <                                                                       $outputBuffer .= "(";
  189. <                                                                      
  190. <                                                                       $first = true;
  191. <                                                                      
  192. <                                                                       for ($i=0; $i<sizeof($columnList); $i++) {
  193. <                                                                               if (!$first)
  194. <                                                                                       $outputBuffer .= ", ";
  195. <                                                                              
  196. <                                                                               $currentData = $dataRow[$columnList[$i]];
  197. <                                                                              
  198. <                                                                               if (isset($type) && $currentData && ((isset($binaryDTs) && in_array($type[$i], $binaryDTs)) || stristr($type[$i], "binary") !== false)) {
  199. <                                                                                       $outputBuffer .= "0x" . bin2hex($currentData);
  200. <                                                                               } else {
  201. <                                                                                       $outputBuffer .= "'" . $conn->escapeString($currentData) . "'";
  202. <                                                                               }
  203. <                                                                              
  204. <                                                                               $first = false;
  205. <                                                                       }
  206. <                                                                      
  207. <                                                                       $outputBuffer .= ")";
  208. <                                                                      
  209. <                                                                       if ($insertType == "COMPLETE")
  210. <                                                                               $outputBuffer .= ";\r\n";
  211. <                                                                      
  212. <                                                                       $firstLine = false;
  213. <                                                                      
  214. <                                                               }
  215. <                                                              
  216. <                                                               if ($insertType == "COMPACT")
  217. <                                                                       $outputBuffer .= ";\r\n";
  218. <                                                              
  219. <                                                       } else {
  220. <                                                               $outputBuffer .= "-- [" . sprintf(__("Table `%s` is empty"), $t) . "]\r\n";
  221. <                                                       }
  222. <                                                      
  223. <                                               } else if ($conn->getAdapter() == "sqlite") {
  224. <                                                      
  225. <                                                       $dataSQL = $conn->query("SELECT * FROM '$t'");
  226. <                                                      
  227. <                                                       // put the column names in an array
  228. <                                                       if ($conn->isResultSet($structureSQL)) {
  229. <                                                               foreach ($structureSQL as $structureRow) {
  230. <                                                                       $columnList[] = $structureRow[0];
  231. <                                                                       $type[] = $structureRow[1];
  232. <                                                               }
  233. <                                                       }
  234. <                                                      
  235. <                                                       $columnImplosion = implode("', '", $columnList);
  236. <                                                      
  237. <                                                       if ($conn->isResultSet($dataSQL)) {
  238. <                                                              
  239. <                                                               $firstLine = true;
  240. <                                                              
  241. <                                                               while ($dataRow = $conn->fetchAssoc($dataSQL)) {
  242. <                                                                      
  243. <                                                                       $outputBuffer .= "INSERT INTO '$t' ('$columnImplosion') VALUES (";
  244. <                                                                      
  245. <                                                                       $first = true;
  246. <                                                                      
  247. <                                                                       for ($i=0; $i<sizeof($columnList); $i++) {
  248. <                                                                               if (!$first)
  249. <                                                                                       $outputBuffer .= ", ";
  250. <                                                                              
  251. <                                                                               $currentData = $dataRow[$columnList[$i]];
  252. <                                                                              
  253. <                                                                               $outputBuffer .= "'" . $conn->escapeString($currentData) . "'";
  254. <                                                                              
  255. <                                                                               $first = false;
  256. <                                                                       }
  257. <                                                                      
  258. <                                                                       $outputBuffer .= ");\r\n";
  259. <                                                                      
  260. <                                                                       $firstLine = false;
  261. <                                                                      
  262. <                                                               }
  263. <                                                              
  264. <                                                       } else {
  265. <                                                               $outputBuffer .= "-- [" . sprintf(__("Table `%s` is empty"), $t) . "]\r\n";
  266. <                                                       }
  267. <                                                      
  268. <                                               }
  269. <                                       }
  270. <                                      
  271. <                                       $outputBuffer .= "\r\n";
  272. <                                      
  273. <                               } else if ($format == "CSV") {
  274. <                                      
  275. <                                       if (isset($printFieldnames)) {
  276. <                                               $structureSQL = $conn->describeTable($t);
  277. <                                                      
  278. <                                               if ($conn->isResultSet($structureSQL)) {
  279. <                                                       $first = true;
  280. <                                                      
  281. <                                                       if ($conn->getAdapter() == "mysql") {
  282. <                                                              
  283. <                                                               while ($structureRow = $conn->fetchArray($structureSQL)) {
  284. <                                                                       if (!$first)
  285. <                                                                               $outputBuffer .= $delimiter;
  286. <                                                                      
  287. <                                                                       $outputBuffer .= "\"" . $structureRow[0] . "\"";
  288. <                                                                      
  289. <                                                                       $first = false;
  290. <                                                               }
  291. <                                                              
  292. <                                                       } else if ($conn->getAdapter() == "sqlite") {
  293. <                                                              
  294. <                                                               foreach ($structureSQL as $structureRow) {
  295. <                                                                       if (!$first)
  296. <                                                                               $outputBuffer .= $delimiter;
  297. <                                                                      
  298. <                                                                       $outputBuffer .= "\"" . $structureRow[0] . "\"";
  299. <                                                                      
  300. <                                                                       $first = false;
  301. <                                                               }
  302. <                                                              
  303. <                                                       }
  304. <                                                      
  305. <                                                       $outputBuffer .= "\r\n";
  306. <                                               }
  307. <                                       }
  308. <                                      
  309. <                                       if ($conn->getAdapter() == "mysql") {
  310. <                                               $dataSQL = $conn->query("SELECT * FROM `$t`");
  311. <                                       } else if ($conn->getAdapter() == "sqlite") {
  312. <                                               $dataSQL = $conn->query("SELECT * FROM '$t'");
  313. <                                       }
  314. <                                      
  315. <                                       if ($conn->isResultSet($dataSQL)) {
  316. <                                               while ($dataRow = $conn->fetchArray($dataSQL)) {
  317. <                                                       $data = array();
  318. <                                                       foreach ($dataRow as $each) {
  319. <                                                               $data[] = "\"" . formatDataForCSV($each) . "\"";
  320. <                                                       }
  321. <                                                      
  322. <                                                       $dataLine = implode($delimiter, $data);
  323. <                                                      
  324. <                                                       $outputBuffer .= $dataLine . "\r\n";
  325. <                                               }
  326. <                                       }
  327. <                                      
  328. <                               }
  329. <                              
  330. <                       }
  331. ---
  332. >                 foreach ($tables as $t) {
  333. >                    
  334. >                     if ($format == "SQL") {
  335. >                        
  336. >                         if ($conn->getAdapter() == "mysql")
  337. >                             $structureSQL = $conn->query("SHOW FULL FIELDS FROM `$t`");
  338. >                         else
  339. >                             $structureSQL = $conn->describeTable($t);
  340. >                        
  341. >                         $tableEngine = "";
  342. >                         $tableCharset = "";
  343. >                         $autoIncrement = "";
  344. >                        
  345. >                         if (isset($exportStructure)) {
  346. >                            
  347. >                             if ($conn->isResultSet($structureSQL)) {
  348. >                                
  349. >                                 if ($conn->getAdapter() == "mysql") {
  350. >                                    
  351. >                                     $outputBuffer .= "CREATE TABLE `$t` (";
  352. >                                    
  353. >                                     $infoSql = $conn->query("SHOW TABLE STATUS LIKE '$t'");
  354. >                                    
  355. >                                     if ($conn->isResultSet($infoSql) == 1) {
  356. >                                        
  357. >                                         $infoRow = $conn->fetchAssoc($infoSql);
  358. >                                        
  359. >                                         $tableEngine = (array_key_exists("Type", $infoRow)) ? $infoRow['Type'] : $infoRow['Engine'];
  360. >                                        
  361. >                                         if (array_key_exists('Collation', $infoRow) && isset($collationList)) {
  362. >                                             $tableCharset = $collationList[$infoRow['Collation']];
  363. >                                         }
  364. >                                        
  365. >                                         if (array_key_exists('Auto_increment', $infoRow))
  366. >                                         {
  367. >                                             $autoIncrement = $infoRow['Auto_increment'];
  368. >                                         }
  369. >                                     }
  370. >                                    
  371. >                                 } else if ($conn->getAdapter() == "sqlite") {
  372. >                                    
  373. >                                     $outputBuffer .= "CREATE TABLE '$t' (";
  374. >                                 }
  375. >                                
  376. >                                 $first = true;
  377. >                                
  378. >                                 if ($conn->getAdapter() == "mysql") {
  379. >                                
  380. >                                     while ($structureRow = $conn->fetchassoc($structureSQL)) {
  381. >                                        
  382. >                                         if (!$first)
  383. >                                             $outputBuffer .= ",";
  384. >                                        
  385. >                                         $outputBuffer .= "\r\n   `" . $structureRow['Field'] . "` " . $structureRow['Type'];
  386. >                                        
  387. >                                         if (isset($collationList) && isset($structureRow['Collation']) && $structureRow['Collation'] != "NULL" && !is_null($structureRow['Collation'])) {
  388. >                                             if ($collationList[$structureRow['Collation']] != $tableCharset) {
  389. >                                                 $outputBuffer .= " CHARSET " . $collationList[$structureRow['Collation']];
  390. >                                             }
  391. >                                         }
  392. >                                        
  393. >                                         if (isset($structureRow['Null']) && $structureRow['Null'] != "YES")
  394. >                                             $outputBuffer .= " not null";
  395. >                                        
  396. >                                         if (isset($structureRow['Default']) && $structureRow['Default'] == "CURRENT_TIMESTAMP") {
  397. >                                             $outputBuffer .= " default CURRENT_TIMESTAMP";
  398. >                                         } else if (isset($structureRow['Default']) && $structureRow['Default'] != "") {
  399. >                                             $outputBuffer .= " default '" . $structureRow['Default'] . "'";
  400. >                                         }
  401. >                                        
  402. >                                         if (isset($structureRow['Extra']) && $structureRow['Extra'] != "")
  403. >                                             $outputBuffer .= " " . $structureRow['Extra'];
  404. >                                        
  405. >                                         $first = false;
  406. >                                     }
  407. >                                
  408. >                                 } else if ($conn->getAdapter() == "sqlite") {
  409. >                                    
  410. >                                     foreach ($structureSQL as $structureRow) {
  411. >                                        
  412. >                                         if (!$first)
  413. >                                             $outputBuffer .= ",";
  414. >                                        
  415. >                                         $outputBuffer .= "\r\n   " . $structureRow[0] . " " . $structureRow[1];
  416. >                                        
  417. >                                         $first = false;
  418. >                                     }
  419. >                                    
  420. >                                 }
  421. >                                
  422. >                                 // dont forget about the keys
  423. >                                 if ($conn->getAdapter() == "mysql") {
  424. >                                     $keySQL = $conn->query("SHOW INDEX FROM `$t`");
  425. >                                    
  426. >                                     if ($conn->isResultSet($keySQL)) {
  427. >                                         $currentKey = "";
  428. >                                         while ($keyRow = $conn->fetchAssoc($keySQL)) {
  429. >                                             // if this is the start of a key
  430. >                                             if ($keyRow['Key_name'] != $currentKey) {
  431. >                                                 // finish off the last key first, if necessary
  432. >                                                 if ($currentKey != "")
  433. >                                                     $outputBuffer .= ")";
  434. >                                                
  435. >                                                 if ($keyRow['Key_name'] == "PRIMARY")
  436. >                                                     $outputBuffer .= ",\r\n   PRIMARY KEY (";
  437. >                                                 elseif ($keyRow['Non_unique'] == "0")
  438. >                                                     $outputBuffer .= ",\r\n   UNIQUE KEY (";
  439. >                                                 else
  440. >                                                     $outputBuffer .= ",\r\n   KEY `" . $keyRow['Key_name'] . "` (";
  441. >                                                
  442. >                                                 $outputBuffer .= "`" . $keyRow['Column_name'] . "`";
  443. >                                             } else {
  444. >                                                 $outputBuffer .= ",`" . $keyRow['Column_name'] . "`";
  445. >                                             }
  446. >                                            
  447. >                                             $currentKey = $keyRow['Key_name'];
  448. >                                         }
  449. >                                        
  450. >                                         if (isset($currentKey) && $currentKey != "")
  451. >                                             $outputBuffer .= ")";
  452. >                                     }
  453. >                                 }
  454. >                                
  455. >                                 $outputBuffer .= "\r\n)";
  456. >                                
  457. >                                 if ($conn->getAdapter() == "mysql") {
  458. >                                     if ($tableEngine) {
  459. >                                         $outputBuffer .= ' ENGINE=' . $tableEngine;
  460. >                                     }
  461. >                                    
  462. >                                     if ($tableCharset) {
  463. >                                         $outputBuffer .= ' DEFAULT CHARSET=' . $tableCharset;
  464. >                                     }
  465. >                                    
  466. >                                     if ($autoIncrement)
  467. >                                     {
  468. >                                         $outputBuffer .= ' AUTO_INCREMENT=' . $autoIncrement;
  469. >                                     }
  470. >                                 }
  471. >                                
  472. >                                 $outputBuffer .= ";\r\n\r\n";
  473. >                             }
  474. >                         }
  475. >                        
  476. >                         if ($conn->getAdapter() == "mysql")
  477. >                             $structureSQL = $conn->query("SHOW FULL FIELDS FROM `$t`");
  478. >                         else
  479. >                             $structureSQL = $conn->describeTable($t);
  480. >                        
  481. >                         if (isset($exportData)) {
  482. >                            
  483. >                             $columnList = array();
  484. >                            
  485. >                             if ($conn->getAdapter() == "mysql") {
  486. >                                
  487. >                                 $dataSQL = $conn->query("SELECT * FROM `$t`");
  488. >                                
  489. >                                 // put the column names in an array
  490. >                                 if ($conn->isResultSet($structureSQL)) {
  491. >                                     while ($structureRow = $conn->fetchAssoc($structureSQL)) {
  492. >                                         $columnList[] = $structureRow['Field'];
  493. >                                         $type[] = $structureRow['Type'];
  494. >                                     }
  495. >                                 }
  496. >                                
  497. >                                 $columnImplosion = implode("`, `", $columnList);
  498. >                                
  499. >                                 if ($conn->isResultSet($dataSQL)) {
  500. >                                    
  501. >                                     if ($insertType == "COMPACT")
  502. >                                         $outputBuffer .= "INSERT INTO `$t` (`$columnImplosion`) VALUES \r\n";
  503. >                                    
  504. >                                     $firstLine = true;
  505. >                                    
  506. >                                     while ($dataRow = $conn->fetchAssoc($dataSQL)) {
  507. >                                        
  508. >                                         if ($insertType == "COMPLETE") {
  509. >                                             $outputBuffer .= "INSERT INTO `$t` (`$columnImplosion`) VALUES ";
  510. >                                         } else {
  511. >                                             if (!$firstLine)
  512. >                                                 $outputBuffer .= ",\r\n";
  513. >                                         }
  514. >                                        
  515. >                                         $outputBuffer .= "(";
  516. >                                        
  517. >                                         $first = true;
  518. >                                        
  519. >                                         for ($i=0; $i<sizeof($columnList); $i++) {
  520. >                                             if (!$first)
  521. >                                                 $outputBuffer .= ", ";
  522. >                                            
  523. >                                             $currentData = $dataRow[$columnList[$i]];
  524. >                                            
  525. >                                             if (isset($type) && $currentData && ((isset($binaryDTs) && in_array($type[$i], $binaryDTs)) || stristr($type[$i], "binary") !== false)) {
  526. >                                                 $outputBuffer .= "0x" . bin2hex($currentData);
  527. >                                             } else {
  528. >                                                 $outputBuffer .= "'" . $conn->escapeString($currentData) . "'";
  529. >                                             }
  530. >                                            
  531. >                                             $first = false;
  532. >                                         }
  533. >                                        
  534. >                                         $outputBuffer .= ")";
  535. >                                        
  536. >                                         if ($insertType == "COMPLETE")
  537. >                                             $outputBuffer .= ";\r\n";
  538. >                                        
  539. >                                         $firstLine = false;
  540. >                                        
  541. >                                     }
  542. >                                    
  543. >                                     if ($insertType == "COMPACT")
  544. >                                         $outputBuffer .= ";\r\n";
  545. >                                    
  546. >                                 } else {
  547. >                                     $outputBuffer .= "-- [" . sprintf(__("Table `%s` is empty"), $t) . "]\r\n";
  548. >                                 }
  549. >                                
  550. >                             } else if ($conn->getAdapter() == "sqlite") {
  551. >                                
  552. >                                 $dataSQL = $conn->query("SELECT * FROM '$t'");
  553. >                                
  554. >                                 // put the column names in an array
  555. >                                 if ($conn->isResultSet($structureSQL)) {
  556. >                                     foreach ($structureSQL as $structureRow) {
  557. >                                         $columnList[] = $structureRow[0];
  558. >                                         $type[] = $structureRow[1];
  559. >                                     }
  560. >                                 }
  561. >                                
  562. >                                 $columnImplosion = implode("', '", $columnList);
  563. >                                
  564. >                                 if ($conn->isResultSet($dataSQL)) {
  565. >                                    
  566. >                                     $firstLine = true;
  567. >                                    
  568. >                                     while ($dataRow = $conn->fetchAssoc($dataSQL)) {
  569. >                                        
  570. >                                         $outputBuffer .= "INSERT INTO '$t' ('$columnImplosion') VALUES (";
  571. >                                        
  572. >                                         $first = true;
  573. >                                        
  574. >                                         for ($i=0; $i<sizeof($columnList); $i++) {
  575. >                                             if (!$first)
  576. >                                                 $outputBuffer .= ", ";
  577. >                                            
  578. >                                             $currentData = $dataRow[$columnList[$i]];
  579. >                                            
  580. >                                             $outputBuffer .= "'" . $conn->escapeString($currentData) . "'";
  581. >                                            
  582. >                                             $first = false;
  583. >                                         }
  584. >                                        
  585. >                                         $outputBuffer .= ");\r\n";
  586. >                                        
  587. >                                         $firstLine = false;
  588. >                                        
  589. >                                     }
  590. >                                    
  591. >                                 } else {
  592. >                                     $outputBuffer .= "-- [" . sprintf(__("Table `%s` is empty"), $t) . "]\r\n";
  593. >                                 }
  594. >                                
  595. >                             }
  596. >                         }
  597. >                        
  598. >                         $outputBuffer .= "\r\n";
  599. >                        
  600. >                     } else if ($format == "CSV") {
  601. >                        
  602. >                         if (isset($printFieldnames)) {
  603. >                             $structureSQL = $conn->describeTable($t);
  604. >                                
  605. >                             if ($conn->isResultSet($structureSQL)) {
  606. >                                 $first = true;
  607. >                                
  608. >                                 if ($conn->getAdapter() == "mysql") {
  609. >                                    
  610. >                                     while ($structureRow = $conn->fetchArray($structureSQL)) {
  611. >                                         if (!$first)
  612. >                                             $outputBuffer .= $delimiter;
  613. >                                        
  614. >                                         $outputBuffer .= "\"" . $structureRow[0] . "\"";
  615. >                                        
  616. >                                         $first = false;
  617. >                                     }
  618. >                                    
  619. >                                 } else if ($conn->getAdapter() == "sqlite") {
  620. >                                    
  621. >                                     foreach ($structureSQL as $structureRow) {
  622. >                                         if (!$first)
  623. >                                             $outputBuffer .= $delimiter;
  624. >                                        
  625. >                                         $outputBuffer .= "\"" . $structureRow[0] . "\"";
  626. >                                        
  627. >                                         $first = false;
  628. >                                     }
  629. >                                    
  630. >                                 }
  631. >                                
  632. >                                 $outputBuffer .= "\r\n";
  633. >                             }
  634. >                         }
  635. >                        
  636. >                         if ($conn->getAdapter() == "mysql") {
  637. >                             $dataSQL = $conn->query("SELECT * FROM `$t`");
  638. >                         } else if ($conn->getAdapter() == "sqlite") {
  639. >                             $dataSQL = $conn->query("SELECT * FROM '$t'");
  640. >                         }
  641. >                        
  642. >                         if ($conn->isResultSet($dataSQL)) {
  643. >                             while ($dataRow = $conn->fetchArray($dataSQL)) {
  644. >                                 $data = array();
  645. >                                 foreach ($dataRow as $each) {
  646. >                                     $data[] = "\"" . formatDataForCSV($each) . "\"";
  647. >                                 }
  648. >                                
  649. >                                 $dataLine = implode($delimiter, $data);
  650. >                                
  651. >                                 $outputBuffer .= $dataLine . "\r\n";
  652. >                             }
  653. >                         }
  654. >                        
  655. >                     }
  656. >                    
  657. >                 }
  658. >                
  659. >             }
clone this paste RAW Paste Data