[opinia]Klasa do obsługi MySQL

[splatch]

Czytałem artykuł z działu php - Klasa do obsługi MySQL. Wydaje mi się troszkę nielogiczne zastosowanie takiej, a nie innej konstrukcji klasy.
Rozwiązanie proponowane przez autora uniemożliwia tworzenie zapytań w pętli itp. Wymusza po prostu korzystanie z złożonych pytań lub korzystanie tylko z jednego na raz.
Chodzi mi konkretnie o fragment
[php]<?php
function query($query) {
if($query!="" && $this->database) {
$this->query = $query;
if($this->result) mysql_free_result($this->result);
if($this->result = mysql_query($this->query, $this->connection)) {
$this->lastId = mysql_insert_id();
$this->queries++;
return $this->result;
} else {
$this->error();
}
} else $this->error();
}
?>[/php]
Przypisanie do zmiennej klasowej $result uniemożliwia potem zastosowanie drugiego zapytania.
Takie coś nie będzie działać:
[php]<?php
$sql = new sqlObject;
$sql->connect('localhost', 'root', 'password', 'baza');
$sql->query("SELECT * FROM tabela");

while($row = $sql->fetchArray()) {
$id = $row['id'];
$zapytanie = "SELECT * FROM tabela WHERE wartosc_z_innej_tabeli = '$id'";
$sql->query( $zapytanie );
if( $row2 = $sql->fetchArray() )
{
echo $row2['wartosc_z_innej_tabeli'];
}
echo $row['config_key'].':'.$row['config_value'].'<br>';
}
?>[/php]
To tylko moja opinia. IMO wciąż lepiej stosować typową kontrukcję $sql->fetch_array( $result ); lub tworzyć nowy obiekt na potrzeby wyświetlania wierszy. Wiem, że klasa przedstawiona w tekście pozwala zapomieć o przerzucaniu zmiennych ale niejednokrotnie zachodzi potrzeba budowania zapytań itp. korzystania z dwóch tabel na raz itp.

[wixor]

naturalnie, to co mówisz jest prawdą. Jednakże, zamiast naprawiać błąd, probonuje go obejść: do każdego zapytania strorzyć osobną klasę i osobne połączenie
rzecz jasna, klasa MySQL powinna umożliwiać tworzenie np. klas MySQLquery i dopiero te klasy powinny umożliwiać tworzenie zapytań.

[splatch]

Oto jaka konstrukcja klasy byłaby w miarę rozsądna.
[php]<?php

class sql_db
{
//połacz z baza
function sql_db( $db_host, $db_user, $db_pass, $db_name )
{
if( !$this->connect = @mysql_pconnect( $db_host, $db_user, $db_pass ) )
{
if( !$this->connect = @mysql_connect( $db_host,$db_user, $db_pass ) )
{
exit( 'Przepraszamy, ale strona jest chwilowo niedostępna.' );
}
}
if( $this->connect )
{
if( !$this->select = @mysql_select_db( $db_name ) )
{
exit( 'Przepraszamy, ale strona jest chwilowo niedostępna.' );
}
}
else
{
exit( 'Przepraszamy, ale strona jest chwilowo niedostępna.' );
}
}

function close()
{
return @mysql_close( $this->connect );
}

function query( $query )
{ // zwraca i zapisuje
return $this->result = @mysql_query( $query );
}


function fetch_array( $result = null )
{
if( $result === null )
{
return @mysql_fetch_array( $this->result );
}
else
{
return @mysql_fetch_array( $result );
}
}

function num_rows( $result = null )
{
if( $result === null )
{
return @mysql_num_rows( $this->result );
}
else
{
return @mysql_num_rows( $result );
}
}

function fetch_row( $result )
{
if( $result === null )
{
return @mysql_fetch_row( $this->result );
}
else
{
return @mysql_fetch_row( $result );
}
}

function fetch_object($result)
{
if( $result === null )
{
return @mysql_fetch_object( $this->result );
}
else
{
return @mysql_fetch_object( $result );
}
}

function error()
{
return @mysql_error( $this->connect );
}
}
?>[/php]
Zbudowana w ten sposób klasa obsłuży coś takiego:
[php]<?php
$sql = new sql_db( 'localhost', 'splatch', 'splatch', 'splatch' );
$sql->query( 'SELECT * FROM teksty' );
while( $row = $sql->fetch_array( ) )
{
echo $row['pole'] .'<br>';
}
?>[/php]
i obsłuży coś takiego
[php]<?php
$sql = new sql_db( 'localhost', 'splatch', 'splatch', 'splatch' );
$x = $sql->query( 'SELECT * FROM teksty' );
while( $row = $sql->fetch_array( $x ) )
{
echo $row['tekst'] .'<br>';
$query = $sql->query( 'SELECT * FROM autorzy WHERE autor = "'. $row['autor'] .'"' );
if( $res2 = $sql->fetch_array( $query ) )
{
echo 'Autor '. $row2['nick'];
}
}
?>[/php]
W tej klasie nie jest jeszcze wprowadzone zaawansowane sprawdzanie, czy dane z zapytania zostały wyświetlone itd., ale nic nie stoi na przeszkodzie, aby to zrobić.
Moim zdaniem autor bardziej chciał pokazać wykorzystanie klas do obsługi bazy danych niż przybliżyć sposób budowy samego kodu. Nie abym miał coś przeciwko takiej formie artykułu, ale tak szanujący się wortal jak Webinside.PL powinien dbać o poziom merytoryczny tekstów.

[Grzegorz Winiarski]

Masz racje nie zwróciłem na to uwagi, artykuł już jest poprawiony.

[splatch]

Cieszy mnie to niezmiernie.