Carregamento de arquivos .sql de dentro PHP
https://stackoverflow.com/questions/147821
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Estou criando um script de instalação para um aplicativo que estou desenvolvendo e necessidade de criar bases de dados de forma dinâmica a partir do PHP. Eu tenho-o para criar o banco de dados, mas agora eu preciso de carga em vários arquivos .sql. Eu tinha planejado para abrir o arquivo e mysql_query uma linha de cada vez -. Até que eu olhei para os arquivos de esquema e percebeu que eles não são apenas uma consulta por linha
Então, como faço para carregar um arquivo sql dentro do PHP (como phpMyAdmin faz com seu comando de importação)?
Solução
Eu estou começando a sensação de que todos aqui que responderam a esta pergunta não sabe o que é gostar de ser um desenvolvedor de aplicativos web que permite às pessoas para instalar o aplicativo em seus próprios servidores. hospedagem compartilhada, especialmente, não permitem que você use SQL como a consulta "LOAD DATA" mencionado anteriormente. A maioria dos hosts compartilhados também não permitem que você use shell_exec.
Agora, para responder à OP, sua melhor aposta é apenas para construir um arquivo PHP que contém as suas consultas em uma variável e pode apenas executá-los. Se você está determinado a analisar arquivos .sql, você deve olhar para phpMyAdmin e obter algumas ideias para a obtenção de dados a partir de arquivos .sql que maneira. Olhe ao redor em outras aplicações web que têm instaladores e você verá que, ao invés de arquivos de uso .sql para suas consultas, eles simplesmente empacotá-los em arquivos PHP e apenas correr cada corda através de mysql_query ou o que é que eles precisam fazer .
Outras dicas
$db = new PDO($dsn, $user, $password);
$sql = file_get_contents('file.sql');
$qr = $db->exec($sql);
phpBB utiliza algumas funções para analisar seus arquivos. Eles são bastante bem comentado (o que é uma exceção!) Para que você pode facilmente saber o que eles fazem (Eu tenho esta solução de http://www.frihost.com/forums/vt-8194.html ). aqui está a solução de um Eu usei-o muito:
<php
ini_set('memory_limit', '5120M');
set_time_limit ( 0 );
/***************************************************************************
* sql_parse.php
* -------------------
* begin : Thu May 31, 2001
* copyright : (C) 2001 The phpBB Group
* email : support@phpbb.com
*
* $Id: sql_parse.php,v 1.8 2002/03/18 23:53:12 psotfx Exp $
*
****************************************************************************/
/***************************************************************************
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
***************************************************************************/
/***************************************************************************
*
* These functions are mainly for use in the db_utilities under the admin
* however in order to make these functions available elsewhere, specifically
* in the installation phase of phpBB I have seperated out a couple of
* functions into this file. JLH
*
\***************************************************************************/
//
// remove_comments will strip the sql comment lines out of an uploaded sql file
// specifically for mssql and postgres type files in the install....
//
function remove_comments(&$output)
{
$lines = explode("\n", $output);
$output = "";
// try to keep mem. use down
$linecount = count($lines);
$in_comment = false;
for($i = 0; $i < $linecount; $i++)
{
if( preg_match("/^\/\*/", preg_quote($lines[$i])) )
{
$in_comment = true;
}
if( !$in_comment )
{
$output .= $lines[$i] . "\n";
}
if( preg_match("/\*\/$/", preg_quote($lines[$i])) )
{
$in_comment = false;
}
}
unset($lines);
return $output;
}
//
// remove_remarks will strip the sql comment lines out of an uploaded sql file
//
function remove_remarks($sql)
{
$lines = explode("\n", $sql);
// try to keep mem. use down
$sql = "";
$linecount = count($lines);
$output = "";
for ($i = 0; $i < $linecount; $i++)
{
if (($i != ($linecount - 1)) || (strlen($lines[$i]) > 0))
{
if (isset($lines[$i][0]) && $lines[$i][0] != "#")
{
$output .= $lines[$i] . "\n";
}
else
{
$output .= "\n";
}
// Trading a bit of speed for lower mem. use here.
$lines[$i] = "";
}
}
return $output;
}
//
// split_sql_file will split an uploaded sql file into single sql statements.
// Note: expects trim() to have already been run on $sql.
//
function split_sql_file($sql, $delimiter)
{
// Split up our string into "possible" SQL statements.
$tokens = explode($delimiter, $sql);
// try to save mem.
$sql = "";
$output = array();
// we don't actually care about the matches preg gives us.
$matches = array();
// this is faster than calling count($oktens) every time thru the loop.
$token_count = count($tokens);
for ($i = 0; $i < $token_count; $i++)
{
// Don't wanna add an empty string as the last thing in the array.
if (($i != ($token_count - 1)) || (strlen($tokens[$i] > 0)))
{
// This is the total number of single quotes in the token.
$total_quotes = preg_match_all("/'/", $tokens[$i], $matches);
// Counts single quotes that are preceded by an odd number of backslashes,
// which means they're escaped quotes.
$escaped_quotes = preg_match_all("/(?<!\\\\)(\\\\\\\\)*\\\\'/", $tokens[$i], $matches);
$unescaped_quotes = $total_quotes - $escaped_quotes;
// If the number of unescaped quotes is even, then the delimiter did NOT occur inside a string literal.
if (($unescaped_quotes % 2) == 0)
{
// It's a complete sql statement.
$output[] = $tokens[$i];
// save memory.
$tokens[$i] = "";
}
else
{
// incomplete sql statement. keep adding tokens until we have a complete one.
// $temp will hold what we have so far.
$temp = $tokens[$i] . $delimiter;
// save memory..
$tokens[$i] = "";
// Do we have a complete statement yet?
$complete_stmt = false;
for ($j = $i + 1; (!$complete_stmt && ($j < $token_count)); $j++)
{
// This is the total number of single quotes in the token.
$total_quotes = preg_match_all("/'/", $tokens[$j], $matches);
// Counts single quotes that are preceded by an odd number of backslashes,
// which means they're escaped quotes.
$escaped_quotes = preg_match_all("/(?<!\\\\)(\\\\\\\\)*\\\\'/", $tokens[$j], $matches);
$unescaped_quotes = $total_quotes - $escaped_quotes;
if (($unescaped_quotes % 2) == 1)
{
// odd number of unescaped quotes. In combination with the previous incomplete
// statement(s), we now have a complete statement. (2 odds always make an even)
$output[] = $temp . $tokens[$j];
// save memory.
$tokens[$j] = "";
$temp = "";
// exit the loop.
$complete_stmt = true;
// make sure the outer loop continues at the right point.
$i = $j;
}
else
{
// even number of unescaped quotes. We still don't have a complete statement.
// (1 odd and 1 even always make an odd)
$temp .= $tokens[$j] . $delimiter;
// save memory.
$tokens[$j] = "";
}
} // for..
} // else
}
}
return $output;
}
$dbms_schema = 'yourfile.sql';
$sql_query = @fread(@fopen($dbms_schema, 'r'), @filesize($dbms_schema)) or die('problem ');
$sql_query = remove_remarks($sql_query);
$sql_query = split_sql_file($sql_query, ';');
$host = 'localhost';
$user = 'user';
$pass = 'pass';
$db = 'database_name';
//In case mysql is deprecated use mysqli functions.
mysqli_connect($host,$user,$pass) or die('error connection');
mysqli_select_db($db) or die('error database selection');
$i=1;
foreach($sql_query as $sql){
echo $i++;
echo "<br />";
mysql_query($sql) or die('error in query');
}
?>
A solução mais simples é usar shell_exec () para executar o cliente mysql com o script SQL como entrada. Isso pode correr um pouco mais lento porque tem que garfo, mas você pode escrever o código em um par de minutos e depois voltar a trabalhar em algo útil. Escrever um script PHP para executar qualquer script SQL poderia levar semanas.
Apoio scripts SQL é mais complexa do que as pessoas estão descrevendo aqui, a menos que você tenha certeza de que seu script contém apenas um subconjunto da funcionalidade de scripts. Abaixo estão alguns exemplos de coisas que podem aparecer em um script SQL comum que tornam complexa para o código de um script para interpretá-lo linha por linha.
-- Comment lines cannot be prepared as statements
-- This is a MySQL client tool builtin command.
-- It cannot be prepared or executed by server.
USE testdb;
-- This is a multi-line statement.
CREATE TABLE foo (
string VARCHAR(100)
);
-- This statement is not supported as a prepared statement.
LOAD DATA INFILE 'datafile.txt' INTO TABLE foo;
-- This statement is not terminated with a semicolon.
DELIMITER //
-- This multi-line statement contains a semicolon
-- but not as the statement terminator.
CREATE PROCEDURE simpleproc (OUT param1 INT)
BEGIN
SELECT COUNT(*) INTO param1 FROM foo;
END
//
Se você só suportam um subconjunto de scripts SQL, excluindo alguns casos de canto, tais como aqueles acima, é relativamente fácil escrever um script PHP que lê um arquivo e executa os comandos SQL dentro do arquivo. Mas se você quiser apoiar qualquer script SQL válido, isso é muito mais complexa.
Veja também as minhas respostas a essas perguntas relacionadas:
mysqli pode executar várias consultas separadas por um ;
você poderia ler em todo o arquivo e executá-lo de uma só vez usando mysqli_multi_query()
Mas, eu vou ser o primeiro a dizer que esta não é a solução mais elegante.
Em meus projetos que eu usei solução seguinte:
<?php
/**
* Import SQL from file
*
* @param string path to sql file
*/
function sqlImport($file)
{
$delimiter = ';';
$file = fopen($file, 'r');
$isFirstRow = true;
$isMultiLineComment = false;
$sql = '';
while (!feof($file)) {
$row = fgets($file);
// remove BOM for utf-8 encoded file
if ($isFirstRow) {
$row = preg_replace('/^\x{EF}\x{BB}\x{BF}/', '', $row);
$isFirstRow = false;
}
// 1. ignore empty string and comment row
if (trim($row) == '' || preg_match('/^\s*(#|--\s)/sUi', $row)) {
continue;
}
// 2. clear comments
$row = trim(clearSQL($row, $isMultiLineComment));
// 3. parse delimiter row
if (preg_match('/^DELIMITER\s+[^ ]+/sUi', $row)) {
$delimiter = preg_replace('/^DELIMITER\s+([^ ]+)$/sUi', '$1', $row);
continue;
}
// 4. separate sql queries by delimiter
$offset = 0;
while (strpos($row, $delimiter, $offset) !== false) {
$delimiterOffset = strpos($row, $delimiter, $offset);
if (isQuoted($delimiterOffset, $row)) {
$offset = $delimiterOffset + strlen($delimiter);
} else {
$sql = trim($sql . ' ' . trim(substr($row, 0, $delimiterOffset)));
query($sql);
$row = substr($row, $delimiterOffset + strlen($delimiter));
$offset = 0;
$sql = '';
}
}
$sql = trim($sql . ' ' . $row);
}
if (strlen($sql) > 0) {
query($row);
}
fclose($file);
}
/**
* Remove comments from sql
*
* @param string sql
* @param boolean is multicomment line
* @return string
*/
function clearSQL($sql, &$isMultiComment)
{
if ($isMultiComment) {
if (preg_match('#\*/#sUi', $sql)) {
$sql = preg_replace('#^.*\*/\s*#sUi', '', $sql);
$isMultiComment = false;
} else {
$sql = '';
}
if(trim($sql) == ''){
return $sql;
}
}
$offset = 0;
while (preg_match('{--\s|#|/\*[^!]}sUi', $sql, $matched, PREG_OFFSET_CAPTURE, $offset)) {
list($comment, $foundOn) = $matched[0];
if (isQuoted($foundOn, $sql)) {
$offset = $foundOn + strlen($comment);
} else {
if (substr($comment, 0, 2) == '/*') {
$closedOn = strpos($sql, '*/', $foundOn);
if ($closedOn !== false) {
$sql = substr($sql, 0, $foundOn) . substr($sql, $closedOn + 2);
} else {
$sql = substr($sql, 0, $foundOn);
$isMultiComment = true;
}
} else {
$sql = substr($sql, 0, $foundOn);
break;
}
}
}
return $sql;
}
/**
* Check if "offset" position is quoted
*
* @param int $offset
* @param string $text
* @return boolean
*/
function isQuoted($offset, $text)
{
if ($offset > strlen($text))
$offset = strlen($text);
$isQuoted = false;
for ($i = 0; $i < $offset; $i++) {
if ($text[$i] == "'")
$isQuoted = !$isQuoted;
if ($text[$i] == "\\" && $isQuoted)
$i++;
}
return $isQuoted;
}
function query($sql)
{
global $mysqli;
//echo '#<strong>SQL CODE TO RUN:</strong><br>' . htmlspecialchars($sql) . ';<br><br>';
if (!$query = $mysqli->query($sql)) {
throw new Exception("Cannot execute request to the database {$sql}: " . $mysqli->error);
}
}
set_time_limit(0);
$mysqli = new mysqli('localhost', 'root', '', 'test');
$mysqli->set_charset("utf8");
header('Content-Type: text/html;charset=utf-8');
sqlImport('import.sql');
echo "Peak MB: ", memory_get_peak_usage(true)/1024/1024;
No arquivo de teste sql (41MB) o pico de uso de memória: 3.25Mb
Desde que eu não posso comentar sobre a resposta, cuidado de usar seguinte solução:
$db = new PDO($dsn, $user, $password);
$sql = file_get_contents('file.sql');
$qr = $db->exec($sql);
Há um bug no PHP DOP https://bugs.php.net/bug php? id = 61613
db->exec('SELECT 1; invalidstatement; SELECT 2');
não vai erro fora ou retornar falso (testado em PHP 5.5.14).
A minha sugestão seria a de olhar para o código fonte do PHPMyBackup. É um carregador PHP SQL automatizado. Você vai descobrir que mysql_query carrega apenas uma consulta de cada vez, e projetos como PHPMyAdmin e PHPMyBackup já fez o trabalho duro para você de analisar o SQL da maneira correta. Por favor, não re-inventar a roda: P
Uma solução atualizada de solução Plahcinski. Alternativamente, você pode usar fopen e fread para os ficheiros maiores:
$fp = file('database.sql', FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
$query = '';
foreach ($fp as $line) {
if ($line != '' && strpos($line, '--') === false) {
$query .= $line;
if (substr($query, -1) == ';') {
mysql_query($query);
$query = '';
}
}
}
Você tem certeza que não é uma consulta por linha? Seu editor de texto podem ser linhas de acondicionamento, mas na realidade cada consulta pode ser em uma única linha.
De qualquer forma, o método de Olle parece melhor. Se você tiver razões para executar consultas um de cada vez, você deve ser capaz de ler em seu arquivo linha por linha, em seguida, usar o ponto e vírgula no final de cada consulta para delimitar. Você está muito melhor leitura em um arquivo linha por linha do que tentar dividir uma enorme corda, como ele vai ser muito gentil com a memória do seu servidor. Exemplo:
$query = '';
$handle = @fopen("/sqlfile.sql", "r");
if ($handle) {
while (!feof($handle)) {
$query.= fgets($handle, 4096);
if (substr(rtrim($query), -1) === ';') {
// ...run your query, then unset the string
$query = '';
}
}
fclose($handle);
}
Obviamente, você precisa considerar transações e o resto se você estiver executando uma série de consultas em um lote, mas provavelmente não é um grande negócio para um novo script de instalação.
Obras no Navicat lixeiras. Talvez seja necessário para despejar os primeiros puts / * * / comentário navicat em.
$file_content = file('myfile.sql');
$query = "";
foreach($file_content as $sql_line){
if(trim($sql_line) != "" && strpos($sql_line, "--") === false){
$query .= $sql_line;
if (substr(rtrim($query), -1) == ';'){
echo $query;
$result = mysql_query($query)or die(mysql_error());
$query = "";
}
}
}
Tente isto:
// SQL File
$SQLFile = 'YourSQLFile.sql';
// Server Name
$hostname = 'localhost';
// User Name
$db_user = 'root';
// User Password
$db_password = '';
// DBName
$database_name = 'YourDBName';
// Connect MySQL
$link = mysql_connect($hostname, $db_user, $db_password);
if (!$link) {
die("MySQL Connection error");
}
// Select MySQL DB
mysql_select_db($database_name, $link) or die("Wrong MySQL Database");
// Function For Run Multiple Query From .SQL File
function MultiQuery($sqlfile, $sqldelimiter = ';') {
set_time_limit(0);
if (is_file($sqlfile) === true) {
$sqlfile = fopen($sqlfile, 'r');
if (is_resource($sqlfile) === true) {
$query = array();
echo "<table cellspacing='3' cellpadding='3' border='0'>";
while (feof($sqlfile) === false) {
$query[] = fgets($sqlfile);
if (preg_match('~' . preg_quote($sqldelimiter, '~') . '\s*$~iS', end($query)) === 1) {
$query = trim(implode('', $query));
if (mysql_query($query) === false) {
echo '<tr><td>ERROR:</td><td> ' . $query . '</td></tr>';
} else {
echo '<tr><td>SUCCESS:</td><td>' . $query . '</td></tr>';
}
while (ob_get_level() > 0) {
ob_end_flush();
}
flush();
}
if (is_string($query) === true) {
$query = array();
}
}
echo "</table>";
return fclose($sqlfile);
}
}
return false;
}
/* * * Use Function Like This: ** */
MultiQuery($SQLFile);
mysql_query("LOAD DATA LOCAL INFILE '/path/to/file' INTO TABLE mytable");
Resumidamente, a maneira que eu tenho feito isso é:
-
Leia o arquivo (um despejo db por exemplo
$ mysqldump db > db.sql)$sql = file_get_contents(db.sql); -
Import-lo usando mysqli :: multi_query
if ($mysqli->multi_query($sql)) { $mysqli->close(); } else { throw new Exception ($mysqli->error); }
Watch out suportes mysqli_query assíncrono consultas. Mais aqui: http://php.net/manual/en/mysqli.multi -query.php e aqui https://stackoverflow.com/a/6652908/2002493
A menos que você planeja importar enorme arquivos .sql, basta ler o arquivo inteiro na memória e executá-lo como uma consulta.
Tem sido um tempo desde que eu usei PHP, por isso, o código pseudo:
all_query = read_file("/my/file.sql")
con = mysql_connect("localhost")
con.mysql_select_db("mydb")
con.mysql_query(all_query)
con.close()
A menos que os arquivos são enormes (digamos, ao longo de vários megabytes), não há nenhuma razão para executá-lo linha-de-um-tempo, ou tente e dividi-lo em várias consultas (por divisão usando ;, que como eu comentou em cam8001 resposta, vai quebrar se a consulta tem ponto e vírgula dentro de strings) ..
Este o melhor código Para restaurar sql por php pode usar 100% Goooood! Agradeça a um monte
$file_content = file('myfile.sql');
$query = "";
foreach($file_content as $sql_line){
if(trim($sql_line) != "" && strpos($sql_line, "--") === false){
$query .= $sql_line;
if (substr(rtrim($query), -1) == ';'){
echo $query;
$result = mysql_query($query)or die(mysql_error());
$query = "";
}
}
}
A maneira mais fácil e rápida de carga e descarga phpmyadmin de análise de arquivo de despejo mysql ..
$ mysql -u username -p -h localhost dbname < dumpfile.sql
Eu observei que o driver PostgreSQL DOP não permite que você para executar scripts separados por ponto e vírgula. A fim de executar um arquivo .sql em qualquer banco de dados usando DOP é necessário dividir as declarações em código PHP si mesmo. Aqui está uma solução que parece funcionar muito bem:
https://github.com/diontruter /migrate/blob/master/src/Diontruter/Migrate/SqlScriptParser.php
A classe referenciada fez o truque para mim de uma forma independente do banco de dados, por favor me mensagem se há algum problema. Aqui está como você pode usar o script após adicioná-lo ao seu projeto:
$pdo = new PDO($connectionString, $userName, $password);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$parser = new SqlScriptParser();
$sqlStatements = $parser->parse($fileName);
foreach ($sqlStatements as $statement) {
$distilled = $parser->removeComments($statement);
if (!empty($distilled)) {
$statement = $pdo->prepare($sql);
$affectedRows = $statement->execute();
}
}
Nenhuma das soluções que tenho visto aqui lidam com a necessidade de alterar o delimitador ao criar um procedimento armazenado no servidor onde eu não posso contar em ter acesso a LOAD DATA INFILE. Eu estava esperando para descobrir que alguém já tinha resolvido isso sem ter que vasculhar o código phpMyAdmin para descobrir isso. Como outros, eu também estava no processo de procura de outra pessoa GPL'ed maneira de fazer isso desde que eu estou escrevendo código GPL mim mesmo.
Algumas bibliotecas PHP pode analisar um arquivo SQL feita de várias instruções SQL, explodir-lo corretamente (sem usar um simples ";" explodir, naturalmente), e a executá-los.
Por exemplo, verificar Phing 's PDOSQLExecTask
Apenas para reafirmar o problema para todos:
mysql_query do PHP, automaticamente end-delimita cada comandos SQL, e além disso é muito vago sobre como fazer isso em seu manual. Tudo para além de um comando irá produzir um erro.
Por outro mysql_query é muito bem com uma string contendo comentários no estilo SQL, \ n, \ r ..
A limitação de mysql_query se revela em que o analisador SQL relata o problema a ser directamente para o próximo comando por exemplo.
You have an error in your SQL syntax; check the manual that corresponds to your
MySQL server version for the right syntax to use near 'INSERT INTO `outputdb:`
(`intid`, `entry_id`, `definition`) VALUES...
Aqui está uma solução rápida: (Assumindo SQL bem formatado;
$sqlCmds = preg_split("/[\n|\t]*;[\n|\t]*[\n|\r]$/", $sqlDump);
Muitos anfitriões não vai permitir que você crie seu próprio banco de dados através do PHP, mas você parece ter resolvido isso.
Uma vez que o DB foi criado, você pode manipular e preenchê-lo simplesmente:
mysql_connect ( "localhost");
mysql_query ( "SOURCE file.sql");
Alguns caras (Plahcinski) sugeriu este código:
$file_content = file('myfile.sql');
$query = "";
foreach($file_content as $sql_line){
if(trim($sql_line) != "" && strpos($sql_line, "--") === false){
$query .= $sql_line;
if (substr(rtrim($query), -1) == ';'){
echo $query;
$result = mysql_query($query)or die(mysql_error());
$query = "";
}
}
}
mas eu gostaria de atualizá-lo com o que funcionou para mim:
//selecting my database
$database = 'databaseTitleInFile';
$selectDatabase = mysql_select_db($database, $con);
if(! $selectDatabase )
{
die('Could not select the database: ' . mysql_error());
}
echo "The database " . $database . " selected successfully\n";
//reading the file
$file_path='..\yourPath\to\File';
if(!file_exists($file_path)){
echo "File Not Exists";
}
$file_content = file_get_contents($file_path);
$array = explode("\n", $file_content)
//making queries
$query = "";
foreach($array as $sql_line){
$sql_line=trim($sql_line);
if($sql_line != "" && substr($sql_line, 0, 2) === "--" && strpos($sql_line, "/*") === false){
$query .= $sql_line;
if (substr(rtrim($query), -1) == ';'){
$result = mysql_query($query)or die(mysql_error());
$query = "";
}
}
}
porque é mais abrangente. ; -)
Isto pode ser útil ->
Mais ou menos o que ele faz é a primeira a tomar a string dada para a função (valor das file_get_contents () do seu file.sql) e remover todas as quebras de linha. Em seguida, ele divide os dados por ";" personagem. Em seguida, ele vai para um circuito de tempo, olhando para cada linha da matriz que é criada. Se a linha contém o carácter "`", ele saberá que é uma consulta e execture a função MyQuery () para os dados dada linha.
Código:
function myquery($query) {
mysql_connect(dbhost, dbuser, dbpass);
mysql_select_db(dbname);
$result = mysql_query($query);
if (!mysql_errno() && @mysql_num_rows($result) > 0) {
}
else {
$result="not";
}
mysql_close();
return $result;
}
function mybatchquery ($str) {
$sql = str_replace("\n","",$str)
$sql = explode(";",$str);
$x=0;
while (isset($str[$x])) {
if (preg_match("/(\w|\W)+`(\w|\W)+) {
myquery($str[$x]);
}
$x++
}
return TRUE;
}
function myrows($result) {
$rows = @mysql_num_rows($result);
return $rows;
}
function myarray($result) {
$array = mysql_fetch_array($result);
return $array;
}
function myescape($query) {
$escape = mysql_escape_string($query);
return $escape;
}
$str = file_get_contents("foo.sql");
mybatchquery($str);
Por que não aproveitar o código de phpMyAdmin e usar isso? É uma fonte aberta depois de tudo ...
Eu uso isso o tempo todo:
$sql = explode(";",file_get_contents('[your dump file].sql'));//
foreach($sql as $query)
mysql_query($query);
Espero que o seguinte código vai resolver seu problema muito bem.
//Empty all tables' contents
$result_t = mysql_query("SHOW TABLES");
while($row = mysql_fetch_assoc($result_t))
{
mysql_query("TRUNCATE " . $row['Tables_in_' . $mysql_database]);
}
// Temporary variable, used to store current query
$templine = '';
// Read in entire file
$lines = file($filename);
// Loop through each line
foreach ($lines as $line)
{
// Skip it if it's a comment
if (substr($line, 0, 2) == '--' || $line == '')
continue;
// Add this line to the current segment
$templine .= $line;
// If it has a semicolon at the end, it's the end of the query
if (substr(trim($line), -1, 1) == ';')
{
// Perform the query
mysql_query($templine) or print('Error performing query \'<strong>' . $templine . '\': ' . mysql_error() . '<br /><br />');
// Reset temp variable to empty
$templine = '';
}
}
?>
isso realmente funcionou para mim:
/* load sql-commands from a sql file */
function loadSQLFromFile($url)
{
// ini_set ( 'memory_limit', '512M' );
// set_time_limit ( 0 );
global $settings_database_name;
global $mysqli_object; global $worked; $worked = false;
$sql_query = "";
// read line by line
$lines = file($url);
$count = count($lines);
for($i = 0;$i<$count;$i++)
{
$line = $lines[$i];
$cmd3 = substr($line, 0, 3);
$cmd4 = substr($line, 0, 4);
$cmd6 = substr($line, 0, 6);
if($cmd3 == "USE")
{
// cut away USE ``;
$settings_database_name = substr($line, 5, -3);
}
else if($cmd4 == "DROP")
{
$mysqli_object->query($line); // execute this line
}
else if(($cmd6 == "INSERT") || ($cmd6 == "CREATE"))
{
// sum all lines up until ; is detected
$multiline = $line;
while(!strstr($line, ';'))
{
$i++;
$line = $lines[$i];
$multiline .= $line;
}
$multiline = str_replace("\n", "", $multiline); // remove newlines/linebreaks
$mysqli_object->query($multiline); // execute this line
}
}
return $worked;
}
?>
Eu tenho um ambiente onde nenhuma ferramenta mysql ou phpmyadmin apenas meu aplicativo php conectando a um servidor MySQL em um host diferente, mas eu preciso para executar scripts exportados pelo mysqldump ou myadmin. Para resolver o problema, eu criei um multi_query roteiro como mencionei aqui
Pode processar saída de mysqldump e exportações phpMyAdmin sem ferramenta de linha de comando mysql. Também fiz um pouco de lógica para processar vários arquivos de migração baseado em timestamp armazenado no DB como Rails. Eu sei que ele precisa de mais tratamento de erros, mas atualmente faz o trabalho para mim.
Confira: https://github.com/kepes/php-migration
É pura php e não precisa de quaisquer outras ferramentas. Se você não faz a entrada do usuário processo com ele somente scripts feitos por desenvolvedores ou ferramentas de exportação, você pode usá-lo com segurança.
Esta é a partir de um projeto que estou trabalhando. Basicamente leva qualquer arquivo de texto e extrai as instruções SQL, ignorando comentários e quebras de linha gratuitas.
<?php
/*
ingestSql(string) : string
Read the contents of a SQL batch file, stripping away comments and
joining statements that are broken over multiple lines with the goal
of producing lines of sql statements that can be successfully executed
by PDO exec() or execute() functions.
For example:
-- My SQL Batch
CREATE TABLE foo(
bar VARCHAR(80),
baz INT NOT NULL);
Becomes:
CREATE TABLE foo(bar VARCHAR(80), baz INT NOT NULL);
*/
function ingestSql($sqlFilePath=__DIR__ . "/create-db.sql") {
$sqlFile = file($sqlFilePath);
$ingestedSql = "";
$statement = "";
foreach($sqlFile as $line) {
// Ignore anything between a double-dash and the end of the line.
$commentStart = strpos($line, "--");
if ($commentStart !== false) {
$line = substr($line, 0, $commentStart);
}
// Only process non-blank lines.
if (strlen($line)) {
// Remove any leading and trailing whitespace and append what's
// left of the line to the current statement.
$line = trim($line);
$statement .= $line;
// A semi-colon ends the current statement. Otherwise what was a
// newline becomes a single space;
if (substr($statement, -1) == ";") {
$ingestedSql .= $statement;
$statement = "\n";
}
else {
$statement .= " ";
}
}
}
return $ingestedSql;
}
?>
