é uma boa prática usar mysql_free_result ($ result)?

Estou ciente de que toda a memory de resultados associados é automaticamente liberada no final da execução do script. Mas você recomendaria usá-lo, se eu estiver usando uma série de ações semelhantes às abaixo?

$sql = "select * from products"; $result = mysql_query($sql); if($result && mysql_num_rows($result) > 0) { while($data = mysql_fetch_assoc($result)) { $sql2 = "insert into another_table set product_id = '".$data['product_id']."' , product_name = '".$data['product_name']."' "; $result2 = mysql_query($sql2); **mysql_free_result($result2);** } } 

Obrigado.

Citando a documentação do mysql_free_result :

mysql_free_result() só precisa ser chamado se você estiver preocupado com a quantidade de memory usada para consultas que retornam grandes conjuntos de resultados.
Toda a memory de resultados associada é liberada automaticamente no final da execução do script.

Então, se a documentação diz que geralmente não é necessário chamar essa function, eu diria que não é realmente necessário, nem boa prática, chamar isso 😉

E, apenas para dizer: quase nunca chamo essa function; A memory é liberada no final do script, e cada script não deve comer muita memory.
Uma exceção poderia ser lotes de longa duração que precisam lidar com grandes quantidades de dados, embora …

Sim, é uma boa prática usar mysql_free_result($result) . A documentação citada na resposta aceita é imprecisa. Isso é o que a documentação diz, mas isso não faz sentido. Aqui está o que diz :

mysql_free_result () só precisa ser chamado se você estiver preocupado com a quantidade de memory usada para consultas que retornam grandes conjuntos de resultados. Toda a memory de resultados associada é liberada automaticamente no final da execução do script.

A primeira parte da primeira frase está correta. É verdade que você não precisa usá-lo por outros motivos que não sejam preocupações com a memory. As preocupações com a memory são o único motivo para usá-lo. No entanto, a segunda parte da primeira frase não faz sentido. A afirmação é que você só se preocuparia com a memory para consultas que retornem grandes conjuntos de resultados. Isso é muito enganador, pois existem outros cenários comuns em que a memory é uma preocupação e o chamado mysql_free_result() é uma prática muito boa. Sempre que as consultas podem ser executadas por um número desconhecido de vezes, mais e mais memory será usada se você não ligar para mysql_free_result() . Então, se você executar sua consulta em um loop, ou de uma function ou método, geralmente é uma boa idéia chamar mysql_free_result() . Você só precisa ter cuidado para não liberar o resultado até depois que ele não será mais usado. Você pode proteger-se de ter que pensar sobre quando e como usá-lo, criando suas próprias funções select () e ex () para que você não esteja trabalhando diretamente com os conjuntos de resultados. ( Nenhum dos códigos aqui é exatamente do jeito que eu realmente escrevê-lo, é mais ilustrativo. Você pode querer colocá-los em uma class ou espaço de nome especial, e lançar um tipo de Exceção diferente ou tomar parâmetros adicionais como $class_name , etc. . )

 // call this for select queries that do not modify anything function select($sql) { $array= array(); $rs= query($sql); while($o= mysql_fetch_object($rs)) $array[]= $o; mysql_free_result($rs); return $array; } // call this for queries that modify data function ex($sql) { query($sql); return mysql_affected_rows(); } function query($sql) { $rs= mysql_query($sql); if($rs === false) { throw new Exception("MySQL query error - SQL: \"$sql\" - Error Number: " .mysql_errno()." - Error Message: ".mysql_error()); } return $rs; } 

Agora, se você chamar apenas select() e ex() , você está lidando apenas com variables ​​de object normais e apenas com preocupações de memory normais, em vez de gerenciamento de memory manual. Você ainda precisa pensar sobre preocupações de memory normais, como a quantidade de memory usada pela matriz de objects. Após a variável sair do escopo, ou você configurá-lo manualmente como nulo, ele fica disponível para garbage collection, então o PHP cuida disso para você. Você ainda pode configurá-lo como nulo antes de sair do escopo se o seu código não o utilizar mais e há operações que o seguem, que utilizam uma quantidade desconhecida de memory, como loops e outras chamadas de function. Eu não sei como os conjuntos de resultados e as funções que operam sobre eles são implementados sob o capô (e mesmo que eu fiz, isso pode mudar com versões diferentes / futuras do PHP e do MySQL), então existe a possibilidade de que a function select() aproximadamente dobra a quantidade de memory usada antes do mysql_free_result($rs) ser chamado. No entanto, usando select () ainda elimina o que usualmente é a principal preocupação de mais e mais memory sendo usada durante loops e várias chamadas de function. Se você está preocupado com esse potencial de uso de memory dupla, e você só está trabalhando com uma linha por vez durante uma única iteração, você pode fazer uma function cada () que não duplicará seu uso de memory e ainda irá proteger você pensando em mysql_free_result() :

 each($sql,$fun) { $rs= query($sql); while($o= mysql_fetch_object($rs)) $fun($o); mysql_free_result($rs); } 

Você pode usá-lo assim:

 each("SELECT * FROM users", function($user) { echo $user->username."
"; });

Outra vantagem de usar cada () é que ele não retorna nada, então você não precisa pensar se deseja ou não definir o valor de retorno para nulo mais tarde.

Depende de quão grande sejam suas consultas ou quantas consultas você executa. O PHP libera a memory no final do (s) script (s) automaticamente, mas não durante a execução. Então, se você tiver uma grande quantidade de dados provenientes de uma consulta, melhorá o resultado manualmente.

Eu diria: SIM, é uma boa prática porque você se importa com a memory durante o desenvolvimento ou seus scripts e é isso que faz um bom desenvolvedor 🙂

A resposta é sim sim na mysqli.
Dê uma olhada na documentação PHP mysqli_free_result :

Você sempre deve liberar seu resultado com mysqli_free_result (), quando seu object de resultado não é mais necessário.

Eu costumava testá-lo com a function memory_get_usage:

 echo '
before mysqli free result: '.memory_get_usage(); mysqli_free_result($query[1]); echo '
after mysqli free result'.memory_get_usage();

E é o resultado:

 before mysqli free result:2110088 after mysqli free result:1958744 

E aqui, estamos falando de 151,344 bytes de memory em apenas 1000 linhas de tabela mysql. Como cerca de um milhão de linhas e como é pensar em grandes projetos?
mysqli_free_result() não é apenas para grande quantidade de dados, também é uma boa prática para pequenos projetos.