Oracle, PHP, Klassen und 150 Prozesse...

[Daniel Rohrlack]

Hallo,
ich sitze nun schon seit einigen Tagen und Stunden an einen kleinen Problem.

Doch erst einmal die Ausgangssituation:
Mit PHP-Klassen wird auf Oracle zugegriffen.
Im Grunde ist es ein Frontend mit PHP um auf Oracle Tabellen zuzugreifen und dort zu schreiben/lesen/löschen/usw...
Das Ganze geschieht mittels Klassen die ich selbst geschrieben habe.

Das Problem:
Wenn ich nun durch die Tabellen blätter taucht nach einiger Zeit immer die
Meldung auf:

Warning: oci_connect() [function.oci-connect]: ORA-00020: maximum number of processes (150) exceeded in h:\oracle\ora92\Apache\Apache\htdocs\itist\class\c lass.einlesen.inc on line 188

Alle Verbindungen werden sauber mittels
oci_connect geöffnet, dann wird ein Statement benutzt und am Schluss
wird sauber ein
oci_free_statement und dann ein
oci_close benutzt.
Seltsamerweise tritt dies nicht auf, wenn ich Teile des Skriptes in Schleifen 500 mal aufrufe...

Hat jemand eine Idee was ich noch machen könnte?
Kann man der Datenbank eventuell sagen, dass sie alle Prozesse nach z.Bsp. 20 Minuten beenden soll?
So langsam weiss ich nicht mehr was ich noch versuchen soll....

Mit freundlichen Gruss

Daniel Rohrlack

[R00Ki3]

Ich kann dir nur empfehlen, schau mal im internet nach singleton pattern.

mal etwas pseudocode.

$ora = ora::getInstance();
$ora->query();
....


.... public function __destruct(){
oci_close();
}

Falls es dir nicht weiterhilft und auch singleton pattern du nicht verstehst, dann melde dich einfach.

[Daniel Rohrlack]

Danke für die Antwort, aber das war es leider nicht...
Ich stelle nun die Verbindung ebenfall mit einer Klasse her:

class db {
private $connection;

private static $instance;

public static function connect($User, $Pwd, $db) {
if (self::$instance === null) {
self::$instance = new db();
}
if (self::$instance) {
if (self::$instance->connection === null){
#include("./db.php"); //getting $user, $pwd, $db
self::$instance->connection = oci_connect($User, $Pwd, $db);
}
return self::$instance->connection;
}
}

private function __construct() {
$this->connection = null;
}

public function __destruct() {
if ($this->connection) {
oci_close($this->connection);
$this->connection = null;
}
}

public static function close() {
if (self::$instance) {
if (self::$instance->connection) {
oci_close(self::$instance->connection);
self::$instance->connection = null;
}
}
}
}

Wenn ich in der Funktion __destruct() ein
echo"getrennt";
ausgebe, dann kommt die Meldung jedes Mal...
Kann es sein, dass der Prozess in der Datenbank nicht sauber beendet wird?
Anscheinend macht er nach jedem neuen laden der Seite einen neuen Prozess auf, bis sein Kontingent verbraucht ist.
Seltsamerweise tritt dies nicht auf, wenn ich Verbindungen ausserhalb der Klassen aufmache...
Wenn ich nun aber die Verbindung beim aufrufen der Funktionen übergebe,
tritt der Effekt trotzdem auf...

Noch jemand eine Idee?

[R00Ki3]

Schon mal so versucht?
"Ich hab das ganze nur schnell überflogen, aber womöglich ist das die Lösung"

public static function connect($User, $Pwd, $db) {
if (self::$instance === null) {
self::$instance = new db();
}
if (self::$instance) {
if (self::$instance === null){
#include("./db.php"); //getting $user, $pwd, $db
self::$instance = oci_connect($User, $Pwd, $db);
}
return self::$instance;
}
}

private function __construct() {
$this->instance = null;
}

public function __destruct() {
if ($this->instance) {
oci_close($this->instance);
$this->instance= null;
}
}

//Ich hab mir das ganze nochmal eben kurz angesehen.

Das wird wohl nicht die Lösung sein.

Wie rufst du den die Klasse auf?
$sql = new db();
$sql -> dbconnect($User, $Pwd, $db);

oder eher

$sql = db::connect($User, $Pwd, $db) ;
Falls nicht $sql = db::connect($User, $Pwd, $db);
erstellst du beim öfteren aufruf mehr als eine Verbindung.

füg doch zum .. __destruct(){
print "<pre>";
var_dump($instance);
print "</pre>";
hinzu dann hast du nen überblick...