Witam!
Mam problem z przerobieniem klasy do zarzadzanie sesjami która współpracuje z bazą PostgreSQL na współprace z baza MySQL.
Przykład class-y pochdzi z książki "PHP5 zaawansowane programowanie" zamieszcze poniżej skrypty z ksiażki i jeżeli to możliwe to prosze o pomoc w przeróbce.

[SQL] pobierz, plaintext 
CREATE TABLE sesja uzytkownika (
  "id" SERIAL PRIMARY KEY NOT NULL,
  "identyfikator_sesji_ascii" character varying(32),
  "zalogowany" bool,
  "identyfikator_uzytkownika" int4,
  "ostatnie_dzialanie" timestamp,
  "utworzono" timestamp,	
  "user_agent" character varying(256)
);
 
CREATE TABLE "uzytkownik" (
  "id" SERIAL PRIMARY KEY NOT NULL,
  "nazwa_uzytkownika" character varying(32),
  "md5_haslo" character varying(32),
  "imie" character varying(64),	
  "nazwisko" character varying(64)
);
 
CREATE TABLE "zmienna_sesji" (
  "id" SERIAL PRIMARY KEY NOT NULL,
  "identyfikator_sesji" int4,
  "nazwa_zmiennej" character varying(64),
  "wartosc_zmiennej" text
);
 
INSERT INTO "uzytkownik"(nazwa_uzytkownika, md5_haslo, imie, nazwisko)
VALUES ('edek', '827ccb0eea8a706c4c34a16891f84e7b', 'Edek', 'Tomaszkiewicz');
[SQL] pobierz, plaintext 

plik usersession.phpm

[PHP] pobierz, plaintext 
<?php
  class UserSession {
	private $php_session_id;
	private $native_session_id;
	private $dbhandle;
	private $logged_in;
	private $user_id;
	private $session_timeout = 600;	  # 10 minutowy maksymalny czas nieaktywności sesji
	private $session_lifespan = 3600;	# 1 godzinny maksymalny czas trwania sesji.
 
	public function __construct() {
	  # Łączy z bazą danych
	  $this->dbhandle = pg_connect("host=db dbname=prophp5 user=edek")  or die ("Błąd PostgreSQL: --> " . pg_last_error($this->dbhandle));
	  # Inicjalizuje mechanizm obsługi sesji
	  session_set_save_handler(
		  array(&$this, '_session_open_method'), 
		  array(&$this, '_session_close_method'), 
		  array(&$this, '_session_read_method'), 
		  array(&$this, '_session_write_method'), 
		  array(&$this, '_session_destroy_method'), 
		  array(&$this, '_session_gc_method')
	  );
	  # Sprawdza przesłane cookie o ile je przesłano; jeżeli wygląda podejrzanie zosta
ja z miejsca anulowane	 
	  $strUserAgent = $GLOBALS["HTTP_USER_AGENT"];
	  if ($_COOKIE["PHPSESSID"]) {
	   # Kontrola bezpieczeństwa i ważności
	   $this->php_session_id = $_COOKIE["PHPSESSID"];
	   $stmt = "SELECT id FROM "sesja_uzytkownika" WHERE identyfikator_sesji_ascii = '" . $this->php_session_id . "' AND ((now() - utworzono) < ' " . $this->session_lifespan . " seconds') AND user_agent='" . $strUserAgent . "' AND ((now() - ostatnia_reakcja) <= '".$this->session_timeout." seconds' OR ostatnia_reakcja IS NULL)";
	   $result = pg_query($stmt);
	   if (pg_num_rows($result)==0) {
		 # Ustawia znacznik niepowodzenia
		  $failed = 1;
		 # Usuwa z bazy danych - w tym samym czasie usuwane są przeterminowane sesje
		 $result = pg_query("DELETE FROM "sesja_uzytkownika" WHERE (identyfikator_sesji_ascii = '". $this->php_session_id . "') OR (now() - utworzono) > $maxlifetime)");
		 # Usuwa nieprzydatne zmienne sesji
		 $result = pg_query("DELETE FROM "zmienna_sesji" WHERE identyfikator_sesji NOT IN (SELECT id FROM "sesja_użytkownika")");
		 # Pozbywa się identyfikatora, wymuszając na php nadanie nowego
		 unset($_COOKIE["PHPSESSID"]);
	   };  
	  };
	  # Ustawia czas życia cookie
	  session_set_cookie_params($this->session_lifespan);
	  # Wywołuje metodę session_start by zainicjować sesję
	  session_start();
	}
 
	public function Impress() {
	  if ($this->native_session_id) {
		$result = pg_query("UPDATE "sesja_uzytkownika" SET ostatnia_reakcja = now() WHERE id = " . $this->native_session_id);
	  };
	}
 
	public function IsLoggedIn() {
	  return($this->logged_in);
	}
 
	public function GetUserID() {
	  if ($this->logged_in) {
		return($this->user_id);
	  } else {
		return(false);
	  };
	}
 
	public function GetUserObject() {
	  if ($this->logged_in) {
		if (class_exists("user")) {
		  $objUser = new User($this->user_id);
		  return($objUser);
		} else {
		  return(false);
		};
	  };
	}
 
	public function GetSessionIdentifier() {
	  return($this->php_session_id);
	}
 
	public function Login($strUsername, $strPlainPassword) {
	   $strMD5Password = md5($strPlainPassword);
	   $stmt = "SELECT id FROM "uzytkownik" WHERE nazwa_uzytkownika = '$strUsername' AND md5_haslo = '$strMD5Password'";
	   $result = pg_query($stmt);
	   if (pg_num_rows($result)>0) {
		  $row = pg_fetch_array($result);
		  $this->user_id = $row["id"];
		  $this->logged_in = true;
		  $result = pg_query("UPDATE "sesja_uzytkownika" SET zalogowany = true, identyfikator_uzytkownika = " . $this->user_id . " WHERE id = " . $this->native_session_id);
		  return(true);
	   } else {
		  return(false);
	   };
	}
 
	public function LogOut() {
	   if ($this->logged_in == true) {
		  $result = pg_query("UPDATE "sesja_uzytkownika" SET zalogowany = false, identyfikator_uzytkownika = 0 WHERE id = " . $this->native_session_id);
		  $this->logged_in = false;
		  $this->user_id = 0;
		  return(true);
	   } else {
		  return(false);
	   };
	}
 
	public function __get($nm) {
	   $result = pg_query("SELECT wartosc_zmiennej FROM zmienna_sesji WHERE identyfikator_sesji = " . $this->native_session_id . " AND nazwa_zmiennej = '" . $nm . "'");
	   if (pg_num_rows($result)>0) {
		  $row = pg_fetch_array($result);
		  return(unserialize($row["wartosc_zmiennej"]));
	   } else {
		  return(false);
	   };
	}
 
 
	public function __set($nm, $val) {
	   $strSer = serialize($val);
	   $stmt = "INSERT INTO zmienna_sesji(identyfikator_sesji, nazwa_zmiennej, wartosc_zmiennej) VALUES(" . $this->native_session_id . ", '$nm', '$strSer')";
	   $result = pg_query($stmt);
	}
 
 
	private function _session_open_method($save_path, $session_name) {
	  # Do nothing
	  return(true);
	}
 
	private function _session_close_method() {
	  pg_close($this->dbhandle);
	  return(true);
	}
 
	private function _session_read_method($id) {
	   # Służy do ustalenia, czy nasza sesja w ogóle istnieje
	   $strUserAgent = $GLOBALS["HTTP_USER_AGENT"];
	   $this->php_session_id = $id;
	   # Na razie ustawia znacznik niepowodzenie na 1
	   $failed = 1;
	   # Sprawdza czy sesja istnieje w bazie danych
	   $result = pg_query("SELECT id, zalogowany, identyfikator_uzytkownika FROM "sesja_uzytkownika" WHERE identyfikator_sesji_ascii = '$id'");
	   if (pg_num_rows($result)>0) {
		  $row = pg_fetch_array($result);
		  $this->native_session_id = $row["id"];
		  if ($row["zalogowany"]=="t") {
			 $this->logged_in = true;
			 $this->user_id = $row["identyfikator_uzytkownika"];
		  } else {
			 $this->logged_in = false;
		  };
	   } else {
		  $this->logged_in = false;
		  # Konieczne jest stworzenie wpisu w bazie danych
		  $result = pg_query("INSERT INTO sesja_uzytkownika(identyfikator_sesji_ascii, zalogowany, identyfikator_uzytkownika, utworzono
, user_agent) VALUES ('$id','f',0,now(),'$strUserAgent')");
		  # Teraz pobiera prawdziwy identyfikator
		  $result = pg_query("SELECT id from "sesja_uzytkownika" WHERE identyfikator_sesji_ascii = '$id'");
		  $row = pg_fetch_array($result);
		  $this->native_session_id = $row["id"];
	   };
	   # Zwraca jedynie ciąg pusty
	   return("");
	}
 
	private function _session_write_method($id, $sess_data) {
	   return(true);
	}
 
	private function _session_destroy_method($id) {
	   $result = pg_query("DELETE FROM "sesja_uzytkownika" WHERE identyfikator_sesji_ascii = '$id'");
	   return($result);
	}
 
 
	private function _session_gc_method($maxlifetime) {
	  return(true);
	}
 
 
  }
?>
[PHP] pobierz, plaintext 

oraz plik testujacy działanie class-y
przeprowadza on logowanie uzytkownika edek oraz jego wylogowanie
usersessiontest.php

[PHP] pobierz, plaintext 
<?php
require_once("usersession.phpm");
 
$objSession = new UserSession();
$objSession->Impress();
?>
Strona testowa klasy UserSession
<HR>
<B>Bieżący identyfikator sesji: </B> <?=$objSession->GetSessionIdentifier();?><BR>
<B>Użytkownik zalogowany? </B> <?=(($objSession->IsLoggedIn() == true) ? "Tak" : "Nie")?><BR>
<BR><BR>
Próba logowania ...
<?php $objSession->Login("edek","12345"); ?>
<BR><BR>
<B>Użytkownik zalogowany? </B> <?=(($objSession->IsLoggedIn() == true) ? "Tak" : "Nie")?><BR>
<B>Identyfikator zalogowanego użytkownika: </B> <?=$objSession->GetUserID();?><BR>
 
<BR><BR>
Wylogowywanie...
<?php $objSession->Logout(); ?>
<BR><BR>
<B>Użytkownik zalogowany? </B> <?=(($objSession->IsLoggedIn() == true) ? "Tak" : "Nie")?><BR>
<BR><BR>
[PHP] pobierz, plaintext 

a na czym konkretnie polega Twoj problem? Z tego co tu widze to musisz funkcje z rodziny pg_... pozamieniac na ich odpowiedniki do mysql, czyli mysql_..... Ot i cala filozofia. W celu sprawdzenia czy istnieje odpowiednik danej funkcji, polecam jak zwykle manuala.

Mam problem z tym fragmentem kodu

[PHP] pobierz, plaintext 
<?php
public function __construct() {
	  # Łączy z bazą danych
	  $this->dbhandle = pg_connect("host=db dbname=prophp5 user=edek")  or die ("Błąd PostgreSQL: --> " . pg_last_error($this->dbhandle));
...
?>
[PHP] pobierz, plaintext 

tu w połączeniu jest odrazu podawana nazwa bazy danych a do MySQL nie znam takiej funkcji
najpierw trzeba by sie połączyć z bazą a dopiero potem przy pomocy funkcji mysql_select_db() wybrać bazę danych.

Jak juz mowilem: polecam manuala. On zna wszystkie funkcje i zazwyczaj jest chetny do dzielenia sie tymi informacjami:
http://pl.php.net/manual/pl/function.mysql-select-db.php

edit:
@NuLL a przegapilem ten tekst a duzo masz tych pralek? Mi sie moja psuje

Gratulujemy - wygrales pralke

Witam,

Mam ta ksiazke. Klasa moze calkiem ciekawa, ale m.in. czytajac ten rozdzial watpilem, czy autorzy to naprawde profesjonalisci. Proponuje, nie zrzynac zywcem klasy, ale co najwyzej napisac swoja, oparta o to cos.

Ja tak zrobilem (nie uzywam jej ;P). Nizej kod:

[PHP] pobierz, plaintext 
<?php
 
class NotLoggedInSessionException extends Exception
{
}
 
class Session
{
  private $_oDatabase;
 
  private static $_oInstance;
 
  private $_sPHPSessionId;
  private $_iNativeSessionId;
  private $_iSessionLifespan = 3600;
  private $_iSessionTimeout = 600;
 
  private $_iUserId;
  private $_bIsLoggedIn;
 
  private function __construct()
  {
	$this->_oDatabase = Database::getInstance();
	$this->_bHasSessionStarted = false;
	$this->_bIsLoggedIn = false;
 
	if(Registry::doesEntryExist('session', 'session-lifespan'))
	  $this->_iSessionLifespan = Registry::getEntry('session', 'session-lifespan');
 
	if(Registry::doesEntryExist('session', 'session-timeout'))
	  $this->_iSessionTimeout = Registry::getEntry('session', 'session-timeout');
 
	if(Registry::doesEntryExist('session', 'session-name'))
	  session_name(Registry::getEntry('session', 'session-name'));
 
	session_set_save_handler
	(
	  array(&$this, '_sessionOpen'),
	  array(&$this, '_sessionClose'),
	  array(&$this, '_sessionRead'),
	  array(&$this, '_sessionWrite'),
	  array(&$this, '_sessionDestroy'),
	  array(&$this, '_sessionGC')
	);
  }
 
  public function start()
  {
	if(!$this->_hasSessionStarted())
	{
	  try
	  {
		$this->_sessionGC();
		$this->_checkForActiveSession();
	  }
	  catch (Exception $oException)
	  {
		throw $oException;
	  }
 
	  session_set_cookie_params($this->_iSessionLifespan);
	  session_start();
	}
  }
 
  public static function getInstance()
  {
	if(!isset(self::$_oInstance))
	{
	  $sClassName = __CLASS__;
	  self::$_oInstance = new $sClassName;
	}
 
	return self::$_oInstance;
  }
 
  public function _sessionOpen($sSavePath, $sSessionName)
  {
	return true;
  }
 
  public function _sessionRead($sPHPSessionId)
  {
	try
	{
	  if(!$this->_hasSessionStarted())
		$this->_createNewSession($sPHPSessionId);
	  else
	  {
		$sQuery = 'SELECT id, logged_in, user_id, vars
				   FROM session
				   WHERE phpsessid = "'.$sPHPSessionId.'"';
 
		$this->_oDatabase->query($sQuery);
 
		$aRow = $this->_oDatabase->fetch();
 
		$this->_iNativeSessionId = $aRow['id'];
		$this->_bLoggedIn = $aRow['logged_in'];
		$this->_iUserId = $aRow['user_id'];
	  }
	}
	catch (Exception $oException)
	{
	  throw $oException;
	}
 
	if(!empty($aRow['vars']))
	  return $aRow['vars'];
	else
	  return '';
  }
 
  public function _sessionWrite($sPHPSessionId, $sData)
  {
	$aToUpdate[] = array('vars', $sData);
 
	try
	{
	  $this->_oDatabase->update('session', $aToUpdate, 'phpsessid = "'.$this->_sPHPSessionId.'"');
	}
	catch (Exception $oException)
	{
	  return false;
	}
 
	return true;
  }
 
  public function _sessionDestroy($sPHPSessionId)
  { return true;
	$sQuery = 'DELETE FROM session
			   WHERE phpsessid = "'.$sPHPSessionId.'"';
 
	try
	{
	  $this->_oDatabase->query($sQuery);
	}
	catch (Exception $oException)
	{
	   throw $oException;
	}
 
	$this->_bIsLoggedIn = false;
 
	return true;
  }
 
  public function _sessionGC($iMaxLifeTime = null)
  {
	$sQuery = 'DELETE FROM session
			   WHERE
				 ((now() - start) > '.$this->_iSessionLifespan.') OR
				 ((now() - last_activity) > '.$this->_iSessionTimeout.')';
 
	try
	{
	  $this->_oDatabase->query($sQuery);
	}
	catch (Exception $oException)
	{
	   throw $oException;
	}
 
	return true;
  }
 
  public function _sessionClose()
  {
	return true;
  }
 
  private function _updateSession()
  {
	if(isset($this->_iNativeSessionId))
	{
	  $aToUpdate[] = array('last_activity', 'now()', false);
 
	  try
	  {
		$this->_oDatabase->update('session', $aToUpdate, 'id = "'.$this->_iNativeSessionId.'"');
	  }
	  catch (Exception $oException)
	  {
		throw $oException;
	  }
	}
  }
 
  private function _hasSessionStarted()
  {
	if(isset($this->_iNativeSessionId))
	  return true;
	else
	  return false;
  }
 
  private function _createNewSession($sPHPSessionId)
  {
	$sUserAgent = $_SERVER['HTTP_USER_AGENT'];
 
	$aToInsert[] = array('phpsessid', $sPHPSessionId);
	$aToInsert[] = array('start', 'now()', false);
	$aToInsert[] = array('user_agent', $sUserAgent);
 
	try
	{
	  $this->_oDatabase->insert('session', $aToInsert);
 
	  $this->_iNativeSessionId = $this->_oDatabase->getInsertId();
 
	  $this->_sPHPSessionId = $sPHPSessionId;
	  $this->_iUserId = 0;
	}
	catch (Exception $oException)
	{
	   throw $oException;
	}
  }
 
  private function _checkForActiveSession()
  {
	$sUserAgent = $_SERVER['HTTP_USER_AGENT'];
 
	$sSessionName = session_name();
 
	if(!empty($_COOKIE[$sSessionName]))
	{
	  $this->_sPHPSessionId = $_COOKIE[$sSessionName];
 
	  $sQuery = 'SELECT id
				 FROM session
				 WHERE
				   phpsessid = "'.$this->_sPHPSessionId.'" AND
				   (
					 (now() - start) < '.$this->_iSessionLifespan.' AND
					 user_agent = "'.$sUserAgent.'" AND
					 (now() - last_activity) <= '.$this->_iSessionTimeout.'
				   ) OR
				   last_activity IS NULL';
 
	  try
	  {
		$this->_oDatabase->query($sQuery);
 
		if($this->_oDatabase->numRows() === 0)
		{
		  unset($_COOKIE[$sSessionName]);
		}
		else
		{
		  $aRow = $this->_oDatabase->fetch();
		  $this->_iNativeSessionId = $aRow['id'];
		  $this->_updateSession();
		}
	  }
	  catch (Exception $oException)
	  {
		throw $oException;
	  }
	}
  }
 
  public function isLoggedIn()
  {
	return $this->_bIsLoggedIn;
  }
 
  public function getUserId()
  {
	if($this->isLoggedIn())
	  return $this->_iUserId;
  }
 
  public function getUserObject()
  {
	if($this->isLoggedIn())
	{
	  try
	  {
	   $oUser = new User($this->getUserId());
	   return $oUser;
	  }
	  catch (Exception $oException)
	  {
		throw $oException;
	  }
	}
	else
	  throw new NotLoggedInSessionException('Can not return object, user have not logged in yet');
  }
 
  public function login($sLogin, $sPlainPassword)
  {
	$sPassword = md5($sPlainPassword);
 
	$sQuery = 'SELECT id FROM users
			   WHERE
				 login = "'.$sLogin.'" AND
				 password = "'.$sPassword.'"';
 
	try
	{
	  $this->_oDatabase->query($sQuery);
	  if($this->_oDatabase->numRows() == 1)
	  {
		$aUser = $this->_oDatabase->fetch();
		$this->_iUserId = $aUser['id'];
 
		$aToUodate[] = array('logged_in', 'true');
		$aToUodate[] = array('user_id', $this->_iUserId);
 
		$this->_oDatabase->update('session', $aToUodate, 'id = "'.$this->_iNativeSessionId.'"');
 
		$this->_bIsLoggedIn = true;
 
		return true;
	  }
	}
	catch (Exception $oException)
	{
	   throw $oException;
	}
  }
 
  public static function logout()
  {
	if($this->isLoggedIn())
	{
	  $aToUodate[] = array('logged_in', false);
	  $aToUodate[] = array('user_id', 0);
 
	  try
	  {
		$this->_oDatabase->update('session', $aToUodate, 'id = "'.$this->_iNativeSessionId.'"');
 
		$this->_bIsLoggedIn = false;
		return true;
	  }
	  catch (Exception $oException)
	  {
		 throw $oException;
	  }
	}
  }
}
?>
[PHP] pobierz, plaintext 

Nie chce mi sie juz jej komentowac, jej bedow tez (bedy przede wszystkim w wyjatkach.)
Uzylem wlasnego silnika bazy. Nizej kod:
Proszę nie umieszczac takich ilosci kodu!!! Usuwam /~nospor/

to ze jest manuala to ja wiem ale nie spotkalem się z taką funkcia do MySQL która laczy sie z bazą i wybiera jednoczenie nazwe bazy.

No i wlasnie dlatego nalezy zrobic to co zaproponowales w poprzednim poscie za co zreszta wygrales pralke