Fehler mit SQL-Abfragen

Seven Secrets · 17. Oktober 2007

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

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 /////////////////////////////////////////////////////

};
?>

Igäl · 18. Oktober 2007

Lass dir doch mal den Query ausgeben und prüfe, ob da alles so ist wie es sein sollte. Wenn du das Gefühl hast, dass es eigentlich klappen sollte, setz den DB-Query mal direkt in deiner DB ab (über phpMyAdmin o.ä.)

Möglicherweise geht der Server/Interpreter deines neuen Hosters anders mit den Quotierungen um als derjenige am alten Ort. Überprüf einfach mal, wie du deine Anführungszeichen gesetzt hast.

Seven Secrets · 19. Oktober 2007

So, jetzt habe ich mir die ganze sache x-mal angesehen und der einzigste Punkt, über den ich stolper ist die, das zwei Tabellen in einer Datenbank gleichzeitig abgefragt werden.

Code:

select * from 'tabelle1' , 'tabelle2'  where content is ...

Ist das überhaupt zulässig?

splasch · 19. Oktober 2007

Ja das ist zulässig und auch korreckt. Bewirk fast das gleiche wie wenn man die Join befehle nutz.

Oft ist es notwendig das man abfragen über mehrer Tabellen machen muß.

Mfg Splasch

Kahmoon · 19. Oktober 2007

Klar. Man kann abfragen über beliebig vielen Tabellen machen. Das ist mit Sicherheit nicht der Fehler.

Sind denn die beiden SQL Versionen gleich?

Seven Secrets · 19. Oktober 2007

Ich habe die DB in beiden Versionen versucht laufen zu lassen. Das dumme ist, es funkioniert in beiden nicht. Also stimmt doch irgendwas an den Abfragen nicht.

Seven Secrets · 19. Oktober 2007

Hier der Quellcode der Abfragen:

PHP:

<?php
class Newsadmin extends TblClass {

   function Newsadmin () {
      $this->TblClass ();
   }


   function ShowFrontendNews ($int_newsId) {
      $str_query .= 'SELECT * FROM '.tbl_news.', '.tbl_template.' WHERE fk_template_id=template_id AND news_id='.$int_newsId;
      $arr_news = $this->SqlQuery($str_query);

      // Bilder auslesen
      if (is_array ($arr_news)) {
         $arr_result = Array ();
      	 foreach ($arr_news as $arr_article) {
            $str_query = 'SELECT * FROM '.tbl_picture.', '.tbl_key_picture_news.' WHERE fk_picture_id=picture_id AND fk_news_id='.$arr_article["news_id"];
            $arr_pictures = $this->SqlQuery($str_query);
            $arr_article["pictures"] = $arr_pictures;
            array_push($arr_result, $arr_article);
         }
      }

      return (array_pop ($arr_result));
   }


   function ListFrontendNews ($int_frontendId, $int_anzArtikel) {
   	  // Tricky Join - List das erste Bild aus (mehr oder weniger zufÃ¤llig)
      $str_query = 'SELECT * FROM '.tbl_news.' as a, '.tbl_key_news_frontend.' as b WHERE b.fk_news_id=a.news_id AND b.fk_frontend_id='.$int_frontendId.' AND active=1 ORDER BY a.date DESC LIMIT 0,'.$int_anzArtikel ;
      $arr_news = $this->SqlQuery($str_query);

      // Bilder auslesen
      if (is_array ($arr_news)) {
         $arr_result = Array ();
      	 foreach ($arr_news as $arr_article) {
            $str_query = 'SELECT * FROM '.tbl_picture.', '.tbl_key_picture_news.' WHERE fk_picture_id=picture_id AND fk_news_id='.$arr_article["news_id"];
            $arr_pictures = $this->SqlQuery($str_query);
            $arr_article["pictures"] = $arr_pictures;
            array_push($arr_result, $arr_article);
         }
      }

      return ($arr_result);
   }



   /**
   * @desc Fï¿½gt ein einzelnes Element ein
   * @param $arr_news ARRAY enthï¿½lt die einzufï¿½genden Daten
   * @return MIX liefert die ID bei Erfolg, sonst false
   */
   function InsertNews ( $arr_news ) {

      return $this->InsertAssoc ( $arr_news, tbl_news );
   }

   /**
   * @desc ï¿½ndert ein bestehendes Element
   * @param $news_id INT identifiziert den zu ï¿½ndernden Datensatz
   * @param $arr_news ARRAY enthï¿½lt die neuen Daten
   * @return BOOL
   */
   function UpdateNews ( $news_id, $arr_news ) {
      $this->UpdateAssoc ( $arr_news, $news_id, 1, tbl_news );

      return true;
   }

   /**
   * @desc Lï¿½scht ein bestehendes Element
   * @param $news_id INT identifiziert den zu lï¿½schenden Datensatz
   * @return BOOL
   */
   function DeleteNews ( $news_id ) {
      $str_query = 'DELETE FROM '.tbl_news.' WHERE news_id="'.$news_id.'"';
      $this->SqlQuery ( $str_query );

      $str_query = 'DELETE FROM '.tbl_key_news_frontend.' WHERE fk_news_id="'.$news_id.'"';
      $this->SqlQuery ( $str_query );

      $str_query = 'DELETE FROM '.tbl_key_picture_news.' WHERE fk_news_id='.$news_id;
      $this->SqlQuery ( $str_query );

      return true;
   }

   /**
   * @desc Liest ein bestehendes Element aus der Datenbank
   * @param $news_id INT identifiziert den auszulesenden Datensatz
   * @return ARRAY enthï¿½lt den Datensatz
   */
   function SelectNews ( $news_id ) {
      $str_query = 'SELECT * FROM '.tbl_news.' WHERE news_id="'.$news_id.'"';
      $arr_news = @array_pop($this->SqlQuery ( $str_query ));

      return $arr_news;
   }


   function CountListNews () {
      $str_query = 'SELECT count(*) FROM '.tbl_news.' ';

      return (@array_pop (@array_pop($this->SqlQuery (  $str_query ))));
   }

   /**
   * @desc Liest alle Elemente aus der Datenbank
   * @return ARRAY enthï¿½lt die Datensï¿½tze
   */
   function ListNews ($int_limitStart = 0, $int_limitOffset = 0) {
      $str_query = 'SELECT * FROM '.tbl_news.' ORDER BY date DESC';
      if ($int_limitOffset) {
         $str_query .= ' LIMIT '.$int_limitStart.','.$int_limitOffset;
      }

      $this->SelectById ( "news_id", $arr_result, $str_query );

      return $arr_result;
   }

   /**
   * @desc Fï¿½gt ein einzelnes Element ein
   * @param $arr_frontend ARRAY enthï¿½lt die einzufï¿½genden Daten
   * @return MIX liefert die ID bei Erfolg, sonst false
   */
   function InsertFrontend ( $arr_frontend ) {

      return $this->InsertAssoc ( $arr_frontend, tbl_frontend );
   }

   /**
   * @desc ï¿½ndert ein bestehendes Element
   * @param $frontend_id INT identifiziert den zu ï¿½ndernden Datensatz
   * @param $arr_frontend ARRAY enthï¿½lt die neuen Daten
   * @return BOOL
   */
   function UpdateFrontend ( $frontend_id, $arr_frontend ) {
      $this->UpdateAssoc ( $arr_frontend, $frontend_id, 1, tbl_frontend );

      return true;
   }

   /**
   * @desc Lï¿½scht ein bestehendes Element
   * @param $frontend_id INT identifiziert den zu lï¿½schenden Datensatz
   * @return BOOL
   */
   function DeleteFrontend ( $frontend_id ) {
      $str_query = 'DELETE FROM '.tbl_frontend.' WHERE frontend_id="'.$frontend_id.'"';
      $this->SqlQuery ( $str_query );

      $str_query = 'DELETE FROM '.tbl_key_news_frontend.' WHERE fk_frontend_id="'.$frontend_id.'"';
      $this->SqlQuery ( $str_query );

      return true;
   }

   /**
   * @desc Liest ein bestehendes Element aus der Datenbank
   * @param $frontend_id INT identifiziert den auszulesenden Datensatz
   * @return ARRAY enthï¿½lt den Datensatz
   */
   function SelectFrontend ( $frontend_id ) {
      $str_query = 'SELECT * FROM '.tbl_frontend.' WHERE frontend_id="'.$frontend_id.'"';
      $arr_frontend = @array_pop($this->SqlQuery ( $str_query ));

      return $arr_frontend;
   }

   /**
   * @desc Liest alle Elemente aus der Datenbank
   * @return ARRAY enthï¿½lt die Datensï¿½tze
   */
   function ListFrontend ($str_orderBy = "frontend_name", $str_dir = "ASC") {
      $str_query = 'SELECT * FROM '.tbl_frontend.' ORDER BY '.$str_orderBy.' '.$str_dir;
      $this->SelectById ( "frontend_id", $arr_result, $str_query );

      return $arr_result;
   }


   function ListNewsFrontend ($int_newsId) {
      $str_query = 'SELECT * FROM '.tbl_key_news_frontend.' WHERE fk_news_id='.$int_newsId;
      $arr_result = $this->SqlQuery($str_query);

      return ($arr_result);
   }


   function InsertKeyNewsFrontend ($int_newsId, $arr_keyFrontends) {
      // Zuerst alle nicht mehr benoetigten alten KeyTbl-Eintraege loeschen

      $str_query = 'DELETE FROM '.tbl_key_news_frontend.' WHERE fk_news_id='.$int_newsId;
   	  $this->SqlQuery($str_query);

   	  // Array mit den ausgewaehlten Frontends durchschleifen und dann eintragen
   	  if (is_array ($arr_keyFrontends)) {
   	     foreach ($arr_keyFrontends as $int_frontend) {
   	     	$str_query = 'INSERT INTO '.tbl_key_news_frontend.' SET fk_news_id='.$int_newsId.', fk_frontend_id='.$int_frontend;
   	     	$this->SqlQuery($str_query);
   	     }
   	  }
   }



   function SelectMediaString ( $picture_id, $bol_thumb ) {
   	  if ($bol_thumb) {
   	  	 $str_query = 'SELECT picture_thumb FROM '.tbl_picture.' WHERE picture_id="'.$picture_id.'"';
   	  	 $arr_picture = @array_pop($this->SqlQuery ( $str_query ));

   	  	 return $arr_picture["picture_thumb"];
   	  } else {
         $str_query = 'SELECT picture FROM '.tbl_picture.' WHERE picture_id="'.$picture_id.'"';
         $arr_picture = @array_pop($this->SqlQuery ( $str_query ));

         return $arr_picture["picture"];
   	  }

   }


   function _PreparePicture (&$arr_media, $arr_file) {

      $arr_media["mimetype"]      = mime_content_type($arr_file["tmp_name"]);
      if ($_FILES["file"]["type"] && !$arr_media["mimetype"]) {
         $arr_media["mimetype"] = $_FILES["file"]["type"];
      }
      $arr_media["media"]         = addslashes(@file_get_contents($arr_file["tmp_name"]));

      if($arr_media["mimetype"] == "image/jpeg" || $arr_media["mimetype"] == "image/png" || $arr_media["mimetype"] == "image/pjpeg"){
         $src_si = getimagesize($arr_file["tmp_name"]);
         if ($arr_media["mimetype"] == "image/jpeg" || $arr_media["mimetype"] == "image/pjpeg") {
            $src_im = imagecreatefromjpeg($arr_file["tmp_name"]);
         } else {
            $src_im = imagecreatefrompng($arr_file["tmp_name"]);
         }

         // Vorschaubild
         $dstW = 100;
         $dstH = 100;
	     $dst_im =  @imagecreatetruecolor ( $dstW, $dstH );
	     if (!$dst_im) {
	        $dst_im =  imagecreate ( $dstW, $dstH );
	     }

         if (($facW = $src_si[0] / $dstW) < ($facH = $src_si[1] / $dstH)){
            $srcW = (int)($src_si[0]);
            $srcH = (int)($src_si[1] * ($facW / $facH));
         } else {
            $srcW = (int)($src_si[0] * ($facH / $facW));
            $srcH = (int)($src_si[1]);
         }

         $srcX = (int)(($src_si[0] - $srcW) / 2);

         @imagecopyresized ( $dst_im, $src_im, 0, 0, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH );
         ob_start();
         imagejpeg($dst_im);
         $arr_media["picture_thumb"] = addslashes(ob_get_contents());
         ob_end_clean();

         // Originalbild
         $arr_media["picture"] = addslashes(@file_get_contents($_FILES["file"]["tmp_name"]));
      }
   }


   /**
   * @desc Fï¿½gt ein einzelnes Element ein
   * @param $arr_picture ARRAY enthï¿½lt die einzufï¿½genden Daten
   * @return MIX liefert die ID bei Erfolg, sonst false
   */
   function InsertPicture ( $arr_picture, $arr_file ) {
      if ($arr_file["tmp_name"]) {
         $this->_PreparePicture($arr_picture, $arr_file);
      }
      return $this->InsertAssoc ( $arr_picture, tbl_picture );
   }


   /**
   * @desc ï¿½ndert ein bestehendes Element
   * @param $picture_id INT identifiziert den zu ï¿½ndernden Datensatz
   * @param $arr_picture ARRAY enthï¿½lt die neuen Daten
   * @return BOOL
   */
   function UpdatePicture ( $picture_id, $arr_picture, $arr_file=FALSE ) {
      if ($arr_file["tmp_name"]) {
         $this->_PreparePicture($arr_picture, $arr_file);
      }

      $this->UpdateAssoc ( $arr_picture, $picture_id, 1, tbl_picture );

      return true;
   }


   /**
   * @desc Lï¿½scht ein bestehendes Element
   * @param $picture_id INT identifiziert den zu lï¿½schenden Datensatz
   * @return BOOL
   */
   function DeletePicture ( $picture_id ) {
      $str_query = 'DELETE FROM '.tbl_picture.' WHERE picture_id="'.$picture_id.'"';
      $this->SqlQuery ( $str_query );

      return true;
   }

   /**
   * @desc Liest ein bestehendes Element aus der Datenbank
   * @param $picture_id INT identifiziert den auszulesenden Datensatz
   * @return ARRAY enthï¿½lt den Datensatz
   */
   function SelectPicture ( $picture_id ) {
      $str_query = 'SELECT * FROM '.tbl_picture.' WHERE picture_id="'.$picture_id.'"';
      $arr_picture = @array_pop($this->SqlQuery ( $str_query ));

      return $arr_picture;
   }


   function CountListPicture () {
      $str_query = 'SELECT count(*) FROM '.tbl_picture.' ';

      return (@array_pop (@array_pop($this->SqlQuery (  $str_query ))));
   }

   /**
   * @desc Liest alle Elemente aus der Datenbank
   * @return ARRAY enthï¿½lt die Datensï¿½tze
   */
   function ListPicture ($int_limitStart, $int_limitOffset) {
   $str_query = 'SELECT * FROM '.tbl_picture.' ORDER BY picture_id DESC';
      if ($int_limitOffset) {
         $str_query .= ' LIMIT '.$int_limitStart.','.$int_limitOffset;
      }

      $this->SelectById ( "picture_id", $arr_result, $str_query );

      return $arr_result;
   }
   /**
   * @desc Fï¿½gt ein einzelnes Element ein
   * @param $arr_template ARRAY enthï¿½lt die einzufï¿½genden Daten
   * @return MIX liefert die ID bei Erfolg, sonst false
   */
   function InsertTemplate ( $arr_template ) {

      return $this->InsertAssoc ( $arr_template, tbl_template );
   }

   /**
   * @desc ï¿½ndert ein bestehendes Element
   * @param $template_id INT identifiziert den zu ï¿½ndernden Datensatz
   * @param $arr_template ARRAY enthï¿½lt die neuen Daten
   * @return BOOL
   */
   function UpdateTemplate ( $template_id, $arr_template ) {
      $this->UpdateAssoc ( $arr_template, $template_id, 1, tbl_template );

      return true;
   }

   /**
   * @desc Lï¿½scht ein bestehendes Element
   * @param $template_id INT identifiziert den zu lï¿½schenden Datensatz
   * @return BOOL
   */
   function DeleteTemplate ( $template_id ) {
      $str_query = 'DELETE FROM '.tbl_template.' WHERE template_id="'.$template_id.'"';
      $this->SqlQuery ( $str_query );

      return true;
   }

   /**
   * @desc Liest ein bestehendes Element aus der Datenbank
   * @param $template_id INT identifiziert den auszulesenden Datensatz
   * @return ARRAY enthï¿½lt den Datensatz
   */
   function SelectTemplate ( $template_id ) {
      $str_query = 'SELECT * FROM '.tbl_template.' WHERE template_id="'.$template_id.'"';
      $arr_template = @array_pop($this->SqlQuery ( $str_query ));

      return $arr_template;
   }

   /**
   * @desc Liest alle Elemente aus der Datenbank
   * @return ARRAY enthï¿½lt die Datensï¿½tze
   */
   function ListTemplate () {
      $str_query = 'SELECT * FROM '.tbl_template.'';
      $this->SelectById ( "template_id", $arr_result, $str_query );

      return $arr_result;
   }


   function SelectLinkedPictures ($int_newsId) {
      $str_query = 'SELECT * FROM '.tbl_key_picture_news.' WHERE fk_news_id='.$int_newsId;
      $arr_result = $this->SqlQuery($str_query);

      return ($arr_result);
   }


   function InsertLinkedPicture ($int_pictureId, $int_newsId, $str_tag) {
      $str_query = 'INSERT INTO '.tbl_key_picture_news.' SET fk_news_id='.$int_newsId.', fk_picture_id='.$int_pictureId.', tag="'.$str_tag.'"';
      $arr_result = $this->SqlQuery($str_query);

      return $arr_result;
   }


   function DelLinkedPicture ($int_pictureId) {
      $str_query = 'DELETE FROM '.tbl_key_picture_news.' WHERE fk_picture_id='.$int_pictureId;

      $arr_result = $this->SqlQuery($str_query);

      return $arr_result;
   }

   function DelLinkedPictures ($int_newsId) {
      $str_query = 'DELETE FROM '.tbl_key_picture_news.' WHERE fk_news_id='.$int_newsId;

      $arr_result = $this->SqlQuery($str_query);

      return $arr_result;
   }


   function LockNews ($int_newsId) {
      $str_query = 'UPDATE '.tbl_news.' SET active=1 WHERE news_id='.$int_newsId;


      return ($this->SqlQuery($str_query));
   }


   function UnlockNews ($int_newsId) {
      $str_query = 'UPDATE '.tbl_news.' SET active=0 WHERE news_id='.$int_newsId;

      return ($this->SqlQuery($str_query));
   }

}
?>

Igäl · 19. Oktober 2007

Mit Verlaub, aber ich muss kurz auf Punkt 4 meiner Signatur verweisen. Was genau funktioniert nicht? Für welchen Fehler sollen wir uns 450 Zeilen Code reinziehen?

Seven Secrets · 19. Oktober 2007

Ohh Entschuldigung, wenn das jetzt nicht so rüber gekommen ist. Also, das Problem ist, dass ich beim Update einer News den oben genannten Fehler bekomme. Und ich nicht nachvollziehen kann, warum das so ist.

Igäl · 19. Oktober 2007

Das sieht nach einem Syntaxfehler im Query-String aus. Poste uns doch mal den Querystring, dann können wir uns das anschauen.

Fehler mit SQL-Abfragen

Seven Secrets

Erfahrenes Mitglied

Igäl

Erfahrenes Mitglied

Seven Secrets

Erfahrenes Mitglied

splasch

Erfahrenes Mitglied

Kahmoon

Erfahrenes Mitglied

Seven Secrets

Erfahrenes Mitglied

Seven Secrets

Erfahrenes Mitglied

Igäl

Erfahrenes Mitglied

Seven Secrets

Erfahrenes Mitglied

Igäl

Erfahrenes Mitglied

Neue Beiträge