Witam

Prosiłbym o sprawdzenie poprawności w napisaniu klasy do "keszowania" zapytań mysql (czy chociaż dobrze zacząłem ją pisać), gdyż nie mam wiedzy na temat zaawansowanego programowania w php (którego trochę mogłem już zapomnieć) i zawsze używałem gotowych klas mysql. Klasa nie jest jeszcze dopracowana.

[PHP] pobierz, plaintext 
//Klasa mysql cache
class mysql
{
	//Ustawienia
	private $folder='temp/'; //Folder cache
 
	//Pomocne w klasie
	private $connect; //Do połączenia i zamykania połączenia z mysql
	public  $row=array(); //Do pobierania wyników z bazy
	private $cache_buffer=array(); //Przechowuje tutaj dane z cache
	public  $cache_stan=0; //Pomaga w zakończeniu pętli w fetch_assoc()
	public  $array_num=0; //Ostatni numer tablicy
	private $zapytanie_bez_cache; //Gdy cache jest nieaktywne przypisuje mu wyniki z mysql_query(), aby móc odtworzyć rekordy z użyciem w funkcji klasy: fetch_assoc
	private $cache_name; //Nazwa pliku cache
	public  $queries=0; //Zlicza zapytania
 
 
	########## Konstruktor ##########
	function __construct($host,$user,$pass,$baza)
	{
		$this->connect=@mysql_connect($host,$user,$pass) or die('Nie mogę się połączyć z mysql <br /> Błąd: '.mysql_error());
		@mysql_select_db($baza) or die('Nie mogę wybrać bazy <br /> Błąd: '.mysql_error());
 
	}
	##############################
 
 
 
	########## Destruktor
	function __destruct()
	{
		@mysql_close($this->connect);
	}
	##############################
 
 
 
	########## Zapytanie ##########
	public function query($zapytanie, $cache=false) //Drugi parametr określa, czy włączyć cache i jednocześnie przypisuje nazwę pliku
	{
 
			$this->cache_name=$cache; //Daje znać, czy użyć cache jednocześnie tworząc nazwę pliku
 
			if($this->cache_name) //Z cachowaniem (czy nazwa pliku cache została podana)
			{	 
 
				if(file_exists(''.$this->folder.''.$this->cache_name.'.plik')) //Gdy plik cache istnieje
				{
					$this->cache_buffer=unserialize(file_get_contents(''.$this->folder.''.$this->cache_name.'.plik')); //Wczytuje tablice z pliku
					$this->array_num=count($this->cache_buffer); //Liczba elementów tablicy
				}
				else //Gdy nie ma pliku cache, to tworzymy go
				{
					$temp=array();
					$wynik=mysql_query($zapytanie) or die('Problem z zapytaniem <br /> Błąd: '.mysql_error()); //Zapytanie do bazy
					$this->queries++; //Liczba zapytań rośnie
 
					while($r=mysql_fetch_assoc($wynik))
					{
						$temp[]= $r;
					}
					ignore_user_abort(1); //Gdzieś spotkałem się z takim zaleceniem
					$this->cache_buffer=$temp; //Przenosi tablicę z wynikami do buffera
					$this->array_num=count($this->cache_buffer); //Liczba elementów tablicy
					@file_put_contents(''.$this->folder.''.$this->cache_name.'.plik',serialize($temp)); //umieszczenie pliku
				}	
				return 1;
			}
			else //Bez cachowania
			{
				$this->zapytanie_bez_cache=mysql_query($zapytanie) or 
				die('Problem z zapytaniem<br /> Błąd: '.mysql_error()); //Zapytanie do bazy, przypisuje je zmiennej, aby móc potem pobrać rekordy
				$this->queries++; //Liczba zapytań rośnie
			}
 
	}
	##############################
 
 
 
	########## Pobieranie wyników ##########
	public function fetch_assoc()
	{	
			if($this->cache_name) //Z cachowaniem
			{
 
				if($this->array_num==$this->cache_stan){ //Czy ilość elementów jest równa numerowi tablicy, jeśli nie, to numer tablicy się zwiększa
					return 0; //Pobrano wszystkie elementy tablicy - koniec pętli
				}
				else
				{
					$this->row = $this->cache_buffer[$this->cache_stan]; //Tworzy tablicę do wyświetlania wyników, począwszy od tablicy z numerem 0
					$this->cache_stan++; return 1; //Pobiera elementy, indeks zwiększa się, pętla trwa
				} 
			}
			else //Bez cachowania
			{
				$this->row = mysql_fetch_assoc($this->zapytanie_bez_cache);
				return $this->row;
			}
	}
	########################################
 
 
 
	########## Mysql_num_rows ##########
	public function num_rows()
	{
		if($this->cache_name) //Z cachowaniem
		{
			return $this->array_num;
		}
		else //Bez cachowania
		{
			return mysql_num_rows($this->zapytanie_bez_cache);
		}
	}
	####################################
 
 
}
 
##################################################
###################### TEST ###################### 
##BENCHMARK
function czas()
{
   $time = explode(" ", microtime());
   $a= (double)$time[0];
   $b= (double)$time[1];
   return $b + $a;
}
##BENCHMARK
 
$poczatek = czas(); 
$x=0;
 
$sql=new mysql('localhost','root','krasnal','baza');
$sql->query('SELECT nazwa FROM rekordy ORDER BY id DESC LIMIT 100','NazwaPlikuCache'); //Drugi parametr tworzy plik cache o takiej nazwie, nie podając go cache się wyłącza
if($sql->num_rows()>0){echo 'Są rekordy ('.$sql->num_rows().')<br />';}else{echo 'brak rekordów!<br />';} //Test mysql_num_rows 
while($sql->fetch_assoc())
{
	$x++;
	echo $x.') '.$sql->row['nazwa'].'<br />';
 
}
	$koniec= czas();
	$c = $koniec - $poczatek;
	echo "<br /><br />czas generowania " . substr($c, 0, 5) . " sek.<br />Zapytań: ".$sql->queries;
##################################################
###################### TEST ###################### 
[PHP] pobierz, plaintext 

• baty za małpy przed funkcjami. Kopiesz sobie grobowiec. Coś pójdzie nie tak, to się tylko naszukasz.
• dlaczego nie PDO/MySQLi?

no troche do poprawienia jest:

1) nie tworz polaczenia w klasie tylko przekazuj polaczenei do klasy

2) tranzakcje i locki

3) nie uzywaj plikow do cachowania bo ci sie to wysypie, w php nie ma mutexow na pliki wiec istnieje prawdopodobienstwo ze kilka procesow php zacznie pisac w tym samym czasie do jednego pliku i uszkodzi cache

4) uzyj persistent storage, np: apc

@erix
"małpy" usunę, sam nie wiem po co je dałem na czas testowania i pisania klasy. Wolę pozostać przy samym MySQL (przyzwyczajenie).

@cepa
W wielu klasach mysql, które przeglądałem to mniej więcej tak jak u mnie tworzono połączenia wewnątrz klasy.
Stosowanie plików cache jest złym rozwiązaniem? Możliwe, że plik cache może się uszkodzić, ale pewnie da się to jakoś zabezpieczyć, żeby nie dochodziło do nadpisywania pliku w tym samym czasie (zresztą żeby tak się stało, to chyba musiałbym mieć serwis, na którym przesiaduje z kilka tys osób online). Wiele serwisów używa cache mysql na plikach. Nie potrzebna jest mi mega zaawansowana klasa, wystarczy mi tylko, żeby była szybka, prosta, stabilna i używała cache

to ze w wielu to widziales to nie znaczy ze bylo to dobre, powiedzonko o muchach i gownie jest chyba najbardziej adekwatne


cache na plikach nie jest zlym rozwiazaniem jak twoja aplikacja radzi sobie z konkurencyjnoscia, przykladowo taka baza danych tez operuje na plikach ale zapis do plikow jest zabezpieczony aby nie bylo sytuacji ze nagle dane z dwoch polaczen zaczna sie nawzajem nadpisywac.
php jest wolne i nawet przy niewielkim ruchu bedziesz mial przeklamania, sproboj uzyc swojego cache jako np: licznik odwiedzin.
poprostu takie rozwiazanie w php nie jest stabilne, apc czy memcache sa o niebo lepsze i szybsze

Czyli w takim razie postaram się zmodyfikować klasę tak, aby połączenie było przekazywane do niej, tylko czy wtedy jest sens użycia mysql_close() w __destruct?
Zna ktoś może jakieś proste sposoby na zabezpieczenie nadpisywania plików w klasie w przypadku kilku połączeń?

nie ma sensu, jak ktos wyzej zauwazyl uzycie PDO byloby wygodniejsze, w destruktorze zwolnilbym referencje do obiektu bo to jest skurwoza podczas testowania pozniej, czyli poprostu $this->_connection = null


nie ma, najprostsze to wlasnie apc, memcache itp itd, poszperaj na necie troche o thread race

Radzę poczytać o tym, czy jest sens stosować to przyzwyczajenie...

Dlaczego?

Transakcje jak już

1) mozna wtedy uzywac obiektu w sytuacji jak potrzebne jest wiecej niz jedna baza, chociazby skrypty migracji itp
2) testowanie, jezeli masz interfejs obiektu poalczenia to mozna zrobic mocka, lub podawac mu inne zrodla danych a kod nadal dziala jak nalezy

Nikt nie powiedział, że klasa połączenia to Singleton? Jeśli nie jest to można się bawić z nieograniczona liczbą obiektów i tym samym baz.

Nie, bo nie jest.

I dobrze, bo nie chciałbym być zmuszony do korzystania z tylko jednego połączenia czy bazy.

Zastanawiam się nad wdrożeniem APC, jednak prawie nic nie słyszałem o tym module (opieram się jedynie teraz na manualu php). Z tego co mi się wydaje dane będą przechowywane gdzieś w pamięci, więc folder cache nie będzie potrzebny?
Czy działanie takiej klasy powinno wyglądać mniej więcej tak?: Sprawdź czy istnieje cache przez apc_exists(), jeżeli tak, to pobiera je przez apc_fetch(), jeżeli nie to tworzy przy pomocy apc_store(). Całe cache kasowane będzie przy pomocy apc_clear_cache(), a elementy przy apc_delete()? Czy używając apc w cache mysql powinno się określać czas żywotności takiego cache?

http://files.ognisco.com/kickasscache/kickasscache-20110608

tutaj jest prosta klaska ktora realizuje cache z apc i jest zabezpieczona przed thread race