Seven Secrets
Erfahrenes Mitglied
Hallo,
Ich bin etwas ratlos. Ich habe für einen Kunden eine Webseite von einem Noname-Provider zu strato umgezogen. jetzt dachte ich, gut das dürfte ja schnell gehen, aber Fehler. Das heißt, auslesen geht gut. Soll er was in die datenbank schreiben kommt folgender Fehler:
- TblClass.SqlQuery-You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'Die Tremsdorfer Blasmusikanten"" , date = "2007101534" WHERE ne Error-Code: 1064
- TblClass.SqlQuery-Query wurde nicht erfolgreich audsgeführt
- TblClass.Update-Query wurde nicht erfolgreich ausgeführt.
- actionhandlernewsadmin.HandleListNews-Es ist ein Fehler aufgetreten
Ich kann mir den Fehler nicht erklären.
Hier das Script
Ich bin etwas ratlos. Ich habe für einen Kunden eine Webseite von einem Noname-Provider zu strato umgezogen. jetzt dachte ich, gut das dürfte ja schnell gehen, aber Fehler. Das heißt, auslesen geht gut. Soll er was in die datenbank schreiben kommt folgender Fehler:
- TblClass.SqlQuery-You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'Die Tremsdorfer Blasmusikanten"" , date = "2007101534" WHERE ne Error-Code: 1064
- TblClass.SqlQuery-Query wurde nicht erfolgreich audsgeführt
- TblClass.Update-Query wurde nicht erfolgreich ausgeführt.
- actionhandlernewsadmin.HandleListNews-Es ist ein Fehler aufgetreten
Ich kann mir den Fehler nicht erklären.
Hier das Script
PHP:
<?
// Tbl-Klasse zum Zugriff auf die Datenbank
class TblClass extends Object { ////////////////////////////////////////////////
var $str_tbl;
var $dbr_link;
var $int_id; // affectedId des letzten INSERT
var $int_rows; // affectedRows nach UPDATE oder DELETE
var $bol_dumpSql = error_debugSql;
function TblClass ($str_db = "db", $str_tbl = "") { /////////////////////////
// Konstruktor der Klasse
// erwartet: - $str_db: Logische Datenbankbezeichner im Skript
// - $str_tbl: physischer Tabellen-Bezeichner
// Liefert: - VOID
// Globalen DB-Zugangsdaten
global $arr_connects;
// Zugangsdaten aus der dbaccess.php
global $arr_db;
// Setzt die Tabelle, auf die in generierten SQL-Statements zugegriffen wird
$this->SetTable($str_tbl);
$str_name = $arr_db[$str_db]["name"];
if (!$arr_connects[$str_db]) {
// falls connects nocht nicht gesetzt wurde, DB-Verbindung einrichten
// (einmaliger Vorgang durch globale Variable $arr_connects
$str_host = $arr_db[$str_db]["host"];
$str_user = $arr_db[$str_db]["user"];
$str_pass = $arr_db[$str_db]["pass"];
// Datenbankverbindung
if (!$this->dbr_link = $arr_connects[$str_db] = @mysql_connect($str_host, $str_user, $str_pass)) {
// Fehlerbehandlung
$this->PushMySqlError ("TblClass.TblClass");
$this->PushError ("TblClass.TblClass-Die Verbindung mit dem Host \"$str_host\" konnte nicht hergestellt werden");
}
// Auswahl der Datenbank
else if (!@mysql_select_db($str_name, $this->dbr_link)) {
// Fehlerbehandlung
$this->PushMySqlError ("TblClass.TblClass");
$this->PushError ("TblClass.TblClass-Die Datenbank \"$str_dbname\" konnte nicht ausgewählt werden");
}
}
else {
$this->dbr_link = $arr_connects[$str_db];
}
} // end TblClass ///////////////////////////////////////////////////////////
function SetTable ($str_tbl) { //////////////////////////////////////////////
// Setzt die aktuelle zu bearbeitende Tabelle
// Erwartet: - $str_tbl: physischer Datenbank-Bezeichner, z.B. die define-
// Variable
// Liefert: - VOID
$this->str_tbl = $str_tbl;
} // end SetTable ///////////////////////////////////////////////////////////
function SqlQuery ($str_query, $bol_getArr = true) { ///
// Führt ein SQL-Statement aus
// Erwartet: - $str_query: SQL-Statement
// - $bol_getArr: Bool-Wert, ob Array oder mySql-Ressource
// zurückgegeben werden soll, standardmässig ein Array
// - $bol_quotes: Bool, ob Ergebnis der DB-Anfrage escaped
// werden soll
// Liefert: - MIX: Ergebnis der Abfrage
// Dumpt bei Bedarf das SQL-Statement auf dem Bildschirm aus
if ($this->bol_dumpSql) { print ($str_query."<br>"); }
// Ausführen des SQL-Queries
if (!$dbr_query = @mysql_query ($str_query, $this->dbr_link)) {
// Fehlerbehandlung
$this->PushMySqlError ("TblClass.SqlQuery");
$this->PushError ("TblClass.SqlQuery-Query wurde nicht erfolgreich audsgeführt");
return false;
}
else {
// Setzen der AffectedId bei einer Insert-Operation
$this->int_id = @mysql_insert_id();
$this->int_rows = @mysql_num_rows();
// Ergebnisbehandlung, Umformung zu Array soweit gewünscht
if ($bol_getArr) {
$arr_result = array();
// Erzeugen einnes assoziativen Arrays als Ergebnis
while ($arr_row = @mysql_fetch_assoc ($dbr_query)) {
array_push ($arr_result, $arr_row);
}
// Ergebnis-Rückgabe
return $arr_result;
}
// Rückgabe des "puren" DB-Ergebnisses
else { return $dbr_query; }
}
} // end SqlQuery ///////////////////////////////////////////////////////////
function TrySqlQuery ($str_query, $bol_getArr = true, $int_tries = 10) {
// Funktionalität wie SqlQuery, es wird lediglich eine übergebene Anzahl
// von Versuchen für die Opertion ausgeführt.
// Erwartet: - $str_query: Auszuführender SQL-Query
// - $bol_getArr: Rückgabe, als Array oder als mySQL-Ressource
// - $int_tries: maximale Anzahl der Versuche
// - $bol_quotes: Flag, ob automatisch Slashes gesetzt werden
// sollen
// Liefert: - ARRAY oder mySQL-Ressource bei erfolgreichem Aus-
// führen der SQL-Abfrage
// - FALSE: sonst
$bol_dumpSql = $this->bol_dumpSql;
$this->bol_dumpSql = 0;
$bol_success = false;
// Fehlerstack "zwischenspeichern"
$this->StoreErrorStack();
// Versuchen, SQL-Abfrage durchzuführen
for ($int_try = 0; $int_try < $int_tries; $int_try++) {
$this->FlushErrorStack();
$mix_result = $this->SqlQuery($str_query, $bol_getArr);
if ($mix_result === false) { $this->PushError('TblClass.TrySqlQuery.Query konnte nach ['.$int_tries.'] Versuchen nicht erfolgreich ausgeführt werden'); }
else {
$bol_success = true;
break;
}
}
if ($bol_dumpSql) { print $str_query."<br>"; }
// Fehlerstack wiederherstellen
$this->RestoreErrorStack();
$this->bol_dumpSql = $bol_dumpSql;
return $bol_success;
} // end TrySqlQuery ////////////////////////////////////////////////////////
function _BuildWOS ($mix_col, $mix_val, $str_op = "=", $str_link = "AND", $str_pref = "WHERE") {
// Erzeugt für eine SQL-Abfrage eine WHERE oder eine SET-Klausel
// Erwartet: - $mix_col: Array of String oder String zur Auswahl der
// Spaltenbezeichner der DB
// - $mix_val: Array of String oder String zur Angabe der
// Werte
// - $str_op: Verknüpfungsoperator, "=" oder "like",
// standardmässig "="
// - $str_link: Verknüpfungsoperator einzelner Klauseln
// "AND" oder "OR", standardmässig "AND"
// - $str_pref: Statemen-Typ, "WHERE" oder "SET", Standard
// ist "WHERE"
// Liefert: STRING: WHERE oder SET-Klausel
// FALSE: sonst
$str_wos = "";
// Überprüfung, ob Array-Länge von Spalten und Werten übereinstimmen
if (is_array($mix_col) && is_array($mix_val) && count($mix_col) == count($mix_val)) {
foreach($mix_col as $str_col) {
$str_val = current($mix_val);
// Zusammensetzen des SQL-Statements
if (strlen($mix_col)) {
$str_wos .= (strlen($str_wos) ? ' '.$str_link.' ' : '').''.$str_col.''.' '.$str_op.' '.($str_val === false ? 'NULL' : '"'.$str_val.'"');
}
next($mix_val);
}
}
else if (is_string($mix_col)) {
if (strlen($mix_col)) { $str_wos = $mix_col.' '.$str_op.' "'.$mix_val.'"'; }
}
else {
$this->PushError ("TblClass._BuildWOS-Columns und Werte sind nicht kompatibel.");
return false;
}
if ($str_wos) { $str_wos = ' '.$str_pref.' '.$str_wos; }
// Rückgabe des Zusammengesetzten SQL-Statements
return $str_wos;
} // end _BuildWOS ///////////////////////////////////////////////////////////
function _BuildOOG ($mix_oog, $str_pref) { ///////////////////////////////////
// Erzeugt eine ORDER oder eine GROUP-Klausel für eine SQL-Abfrage
// Erwartet: - $mix_oog: Array oder String mit Spaltenbezeichnernd
// - $str_pref: "ORDER" oder "GROUP"
// Liefert: STRING: ORDER oder GROUP-Statement
$str_oog = "";
// Unterscheidung, ob Array oder String übergeben wurde
if (is_array ($mix_oog)) {
// Zusammensetzen der Klausel
foreach ($mix_oog as $str_col) {
if (strlen($str_col)) { $str_oog.= ($str_oog ? ', ' : '').$str_col; }
}
}
else if (strlen($mix_oog)) { $str_oog = $mix_oog; }
if ($str_oog) { $str_oog = ' '.$str_pref.' '.$str_oog; }
// Rückgabe des Ergebnisses
return $str_oog;
} // end _BuildOOG //////////////////////////////////////////////////////////
function _BuildLimit ($int_start, $int_max) { ///////////////////////////////
// Erwartet: - $int_start: untere Grenze für LIMIT-Klausel
// - $int_max: obere Grenze für LIMIT-Klausel
// Liefert: STRING: LIMIT-Klausel
$str_limit = "";
$int_start = (int)$int_start;
$int_max = (int)$int_max;
// Unterscheidung, ob obere und untere Grenze vorhanden sind
if (($int_start > 0) && ($int_max >= 0)) { $str_limit = " LIMIT $int_start, $int_max"; }
else if (($int_start == 0) && ($int_max >= 0)) { $str_limit = " LIMIT $int_max"; }
// Rückgabe des Ergebnisses
return $str_limit;
} // end _BuildLimit ////////////////////////////////////////////////////////
function Select ($mix_col = "", $mix_val = "", $mix_group = array(), $mix_order = array(), $int_start = 0, $int_max = -1, $bol_getArr = true) {
// Erzeugt eine komplette SQL-SELECT-Abfrage
// Erwartet: - $mix_col: Array of String oder String der Spalten für die
// WHERE-Bedingung, Standard ist leer
// - $mix_val: Array oder Mix als Werte für die WHERE-
// Bedingung, Standard ist leer
// - $mix_group: Array of String mit Spalten für GROUP-
// Bedingung (optional)
// - $mix_order: Array of String mit Spalten für ORDER-
// Bedingung (optional)
// - $int_start: untere Grenze für LIMIT-Klausel, optional
// - $int_max: obere Grenze für LIMIT-Klausel, optional
// - $bol_getArr: Bool-Wert, ob Array oder mySql-Ressource
// zurückgegeben werden soll, standardmässig ein Array
// - $bol_quotes: Bool, ob Ergebnis der DB-Anfrage escaped
// werden soll
// Liefert: STRING: SQL-SELECT-Statement
// FALSE: sonst
// WHERE-Klausel erzeugen
$str_where = $this->_BuildWOS ($mix_col, $mix_val);
// Fehlerbehandlung für WHERE-Klausel-Erzeugung
if ($str_where === false) {
$this->PushError ("TblClass.Select-Where Bedingung konnte nicht erstellt werden.");
return false;
}
// Erzeugen der ORDER, GROUP und LIMIT-Klauseln
$str_order = $this->_BuildOOG ($mix_order, "ORDER BY");
$str_group = $this->_BuildOOG ($mix_group, "GROUP BY");
$str_limit = $this->_BuildLimit ($int_start, $int_max);
// Zusammensetzen des SQL-Statements
$str_query = 'SELECT * FROM '.$this->str_tbl.''.$str_where.$str_group.$str_order.$str_limit.';';
// SQL-Abfrage an DB senden
$mix_query = $this->SqlQuery ($str_query, $bol_getArr);
// Fehlerbehandlung des DB-Abfrage-Ergebnisses
if ($mix_query === false) {
$this->PushError ("TblClass.Select-Query wurde nicht erfolgreich ausgeführt.");
return false;
}
// Ergebnis-Rückgabe
return $mix_query;
} // end Select /////////////////////////////////////////////////////////////
function SelectByID ($mix_id, &$arr_result, $str_query) {
$dbr_result = $this->SqlQuery($str_query, false);
if($dbr_result === false)
return false;
while($arr_row = @mysql_fetch_assoc($dbr_result)){
if(is_string($mix_id)){
$arr_result[$arr_row[$mix_id]] = $arr_row;
}else if(is_array($mix_id)){
$ptr_pos = &$arr_result;
$i = 0;
foreach($mix_id as $mix_key=>$str_id){
if(count($mix_id) == ++$i){
if(is_string($mix_key)){
$ptr_pos[$mix_key][$arr_row[$str_id]] = $arr_row;
}else{
$ptr_pos[$arr_row[$str_id]] = $arr_row;
}
}else{
if(is_string($mix_key)){
$ptr_pos = &$ptr_pos[$mix_key][$arr_row[$str_id]];
}else{
$ptr_pos = &$ptr_pos[$arr_row[$str_id]];
}
}
}
}else{
return false;
}
}
return true;
}
function Count ($mix_col = "", $mix_val = "", $mix_group = array(), $mix_order = array(), $int_start = 0, $int_max = -1, $bol_getArr = true) {
// Erzeugt eine komplette SQL-SELECT count(*)-Abfrage
// Erwartet: - $mix_col: Array of String oder String der Spalten für die
// WHERE-Bedingung, Standard ist leer
// - $mix_val: Array oder Mix als Werte für die WHERE-
// Bedingung, Standard ist leer
// - $mix_group: Array of String mit Spalten für GROUP-
// Bedingung (optional)
// - $mix_order: Array of String mit Spalten für ORDER-
// Bedingung (optional)
// - $int_start: untere Grenze für LIMIT-Klausel, optional
// - $int_max: obere Grenze für LIMIT-Klausel, optional
// - $bol_getArr: Bool-Wert, ob Array oder mySql-Ressource
// zurückgegeben werden soll, standardmässig ein Array
// - $bol_quotes: Bool, ob Ergebnis der DB-Anfrage escaped
// werden soll
// Liefert: STRING: SQL-SELECT-Statement
// FALSE: sonst
// WHERE-Klausel erzeugen
$str_where = $this->_BuildWOS ($mix_col, $mix_val);
if ($str_where === false) {
$this->PushError ("TblClass.Select-Where Bedingung konnte nicht erstellt werden.");
return false;
}
// Erzeugen der ORDER, GROUP und LIMIT-Klauseln
$str_order = $this->_BuildOOG ($mix_order, "ORDER BY");
$str_group = $this->_BuildOOG ($mix_group, "GROUP BY");
$str_limit = $this->_BuildLimit ($int_start, $int_max);
// Zusammensetzen des SQL-Statements
$str_query = 'SELECT COUNT(*) FROM '.$this->str_tbl.''.$str_where.$str_group.$str_order.$str_limit.';';
// SQL-Abfrage an DB senden
$mix_query = $this->SqlQuery($str_query, $bol_getArr);
// Fehlerbehandlung des DB-Abfrage-Ergebnisses
if ($mix_query === false) {
$this->PushError ("TblClass.Select-Query wurde nicht erfolgreich ausgeführt.");
return false;
}
// Ergebnis-Rückgabe
return $mix_query;
} // end Count //////////////////////////////////////////////////////////////
function Delete ($mix_col = array(), $mix_val = array(), $mix_order = array(), $int_max = -1) {
// Löscht Datensätze aus der DB
// Erwartet: - $mix_col: Array of String oder String der Spalten für die
// WHERE-Bedingung, Standard ist leer
// - $mix_val: Array oder Mix als Werte für die WHERE-
// Bedingung, Standard ist leer
// - $mix_order: Array of String mit Spalten für ORDER-
// Bedingung (optional)
// - $int_max: Anzahl der maximal zu löschenden Datensätze
// Liefert: TRUE: Datensätze wurden gelöscht
// FALSE: sonst
// WHERE-Klausel erzeugen
$str_where = $this->_BuildWOS ($mix_col, $mix_val);
// Fehlerbehandlung der WHERE-Klausel-Erzeugung
if ($str_where === false) {
$this->PushError ("TblClass.Delete-Where Bedingung konnte nicht erstellt werden.");
return false;
}
// Erzeugen der ORDER, GROUP und LIMIT-Klauseln
$str_order = $this->_BuildOOG($mix_order, "ORDER BY");
$str_limit = $this->_BuildLimit(0, $int_max);
// Zusammensetzen des SQL-Statements
$str_query = 'DELETE FROM '.$this->str_tbl.''.$str_where.$str_order.$str_limit.';';
// SQL-Abfrage an DB senden
$mix_query = $this->SqlQuery($str_query, false, false);
// Fehlerbehandlung
if ($mix_query === false) {
$this->PushError ("TblClass.Delete-Query wurde nicht erfolgreich ausgeführt.");
return false;
}
return true;
} // end Delete /////////////////////////////////////////////////////////////
function Update ($mix_setCol, $mix_setVal, $mix_whereCol = array(), $mix_whereVal = array(), $int_max = -1) {
// Update eines oder mehrerer Datensätze
// Erwartet: - mix_setCol: Array of String oder String, welche Spalten
// aktualisiert werden sollen
// - $mix_setVal: Array of String oder Mix mit den neuen Werten
// - $mix_val: Array oder Mix als Werte für die WHERE-
// Bedingung, Standard ist leer
// - $mix_order: Array of String mit Spalten für ORDER-
// Bedingung (optional)
// - $int_max: Anzanhl der Werte, die maximal upgedatet werden
// sollen
// Liefert: TRUE: Datensätze wurden upgedatet
// FALSE: sonst
// SET-Klausel zusammensetzen
$str_set = $this->_BuildWOS($mix_setCol, $mix_setVal, "=", ", ", "SET");
// Fehlerbehandlung
if ($str_set == false) {
$this->PushError ("TblClass.Update-Set Bedingung konnte nicht erstellt werden.");
return false;
}
// WHERE-Klausel zusammensetzen
$str_where = $this->_BuildWOS ($mix_whereCol, $mix_whereVal);
// Fehlerbehandlung
if ($str_where === false) {
$this->PushError ("TblClass.Update-Where Bedingung konnte nicht erstellt werden.");
return false;
}
// LIMIT-Klausel zusammensetzen
$str_limit = $this->_BuildLimit(0, $int_max);
// SQL-Statement erzeugen
$str_query = 'UPDATE '.$this->str_tbl.''.$str_set.$str_where.$str_limit.';';
// SQL-Anfrage an die DB senden
$mix_query = $this->SqlQuery ($str_query, false, false);
// Fehlerbehandlung
if ($mix_query === false) {
$this->PushError ("TblClass.Update-Query wurde nicht erfolgreich ausgeführt.");
return false;
}
return true;
} // Update /////////////////////////////////////////////////////////////////
function UpdateAssoc ( $arr_set, $mix_where, $int_max = -1, $str_tblname = "" ) {
if($str_tblname){
$str_oldtbl = $this->str_tbl;
$this->SetTable($str_tblname);
}
$arr_cols = $this->SqlQuery ( "SHOW COLUMNS FROM ".$this->str_tbl.";" );
$arr_aset = array();
foreach($arr_cols as $arr_col){
if(isset($arr_set[$arr_col["Field"]]) && ($arr_col["Key"] != "PRI")){
$arr_aset[$arr_col["Field"]] = $arr_set[$arr_col["Field"]];
}
}
if(is_array($mix_where)){
$arr_awhere = array();
foreach($arr_cols as $arr_col){
if(isset($mix_where[$arr_col["Field"]])){
$arr_awhere[$arr_col["Field"]] = $mix_where[$arr_col["Field"]];
}
}
}else{
foreach($arr_cols as $arr_col){
if($arr_col["Key"] == "PRI"){
$arr_awhere[$arr_col["Field"]] = $mix_where;
}
}
}
$this->Update(array_keys($arr_aset), array_values($arr_aset), array_keys($arr_awhere), array_values($arr_awhere), $int_max);
if($str_oldtbl){
$this->SetTable($str_oldtbl);
}
return true;
}
function Insert ($mix_col, $mix_val) { //////////////////////////////////////
// Fügt einen Datensatz in die DB ein
// Erwartet: - $mix_col: Array of String oder String mit Spaltenbezeichner
// - $mix_val: Array oder Mix mit Werten
// Liefert: MIX: Datensatz wurde eingefügt, Rückgabe des PK
// FALSE: sonst
// SET-Klausel erzeugen
$str_set = $this->_BuildWOS ($mix_col, $mix_val, "=", ", ", "SET");
// Fehlerbehandlung
if ($str_set == false) {
$this->PushError ("TblClass.Insert-Set Bedingung konnte nicht erstellt werden.");
return false;
}
// SQL-Statement erzeugen
$str_query = 'INSERT INTO '.$this->str_tbl.''.$str_set.';';
// SQL-Abfrage an die DB senden
$mix_query = $this->SqlQuery ($str_query, false, false);
// Fehlerbehandlung
if($mix_query === false) {
$this->PushError ("TblClass.Insert-Query wurde nicht erfolgreich ausgeführt.");
return false;
}
return $this->int_id;
} // end Insert /////////////////////////////////////////////////////////////
function InsertAssoc ( $arr_set, $str_tblname = "" ) {
if($str_tblname){
$str_oldtbl = $this->str_tbl;
$this->SetTable($str_tblname);
}
$arr_cols = $this->SqlQuery ( "SHOW COLUMNS FROM ".$this->str_tbl.";" );
$arr_assoc = array();
foreach($arr_cols as $arr_col){
if(isset($arr_set[$arr_col["Field"]]) && ($arr_col["Key"] != "PRI")){
$arr_assoc[$arr_col["Field"]] = $arr_set[$arr_col["Field"]];
}
}
$int_id = $this->Insert(array_keys($arr_assoc), array_values($arr_assoc));
if($str_oldtbl){
$this->SetTable($str_oldtbl);
}
return $int_id;
}
function InsertOnce ($str_id, $mix_cols, $mix_vals, &$bol_exists) { /////////
// Wie INSERT, fügt das Tupel nur dann ein, wenn dieser noch nicht
// in der Tabelle vorhanden war, liefert ansonsten die ID des bestehenden
// Tupels zurück
// Erwartet: - $str_id: Feld, welches den PK enthält (wird zurückgegeben)
// - $mix_col: Array of String oder String mit Spaltenbezeichner
// - $mix_val: Array oder Mix mit Werten
// - $bol_exists: TRUE oder FALSE, je nachdem, ob Eintrag
// existierte
// Liefert: - MIX: ID des eingefügten oder existierenden Wertes, Unter-
// scheidung in $bol_exists
// - FALSE: sonst
$arr_query = $this->Select($mix_cols, $mix_vals);
if($arr_query === false) {
$this->PushError('TblClass.InsertOnce-Auf ['.$this->str_tbl.'] konnte nicht zugegriffen werden.');
return false;
}
if (count($arr_query) == 0) {
if($this->Insert($mix_cols, $mix_vals) === false){
$this->PushError('TblClass.InsertOnce-In ['.$this->str_tbl.'] konnte nicht eingefügt werden');
return false;
}
$bol_exists = false;
return ($this->int_id);
}
else {
$bol_exists = true;
return ($arr_query[0][$str_id]);
}
} // end InsertOnce /////////////////////////////////////////////////////////
function PushMySqlError ($str_func) { ///////////////////////////////////////
// Fügt die Fehlermeldungen der DB in den eigenen Error-Stack ein
// Erwartet: - $str_func: Funktion, in der der Fehler auftrat
// Liefert: VOID
$str_error .= $str_func."-";
$str_error .= mysql_error();
$str_error .= " Error-Code: ";
$str_error .= mysql_errno();
$this->PushError($str_error);
} // end PushMySqlError /////////////////////////////////////////////////////
};
?>