✔ PDO Mysql

Zwischen-Frage: Wenn du ohnehin prozeduralen Code haben willst, warum nimmst du nicht einfach die prozedurale Schnittstelle von MySQLi?

EDIT: Hab mir das grad noch mal alles angesehen und den Grund für dein counter-Problem gefunden:

PHP Manual hat gesagt.:
PDOStatement::rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement executed by the corresponding PDOStatement object.
Zum Vergrößern anklicken....

Das bedeutet, du kannst du bei Statements den Row-Count abfragen, die irgendwelche Datensätze verändern (löschen,einfügen,ändern).

Wenn du es immer noch über PDO lösen willst, habe ich einen Vorschlag. Den ich aber erst schreibe, wenn du dabei bleiben willst - ist nämlich etwas Arbeit ;-)
 
Zuletzt bearbeitet:
Ja, bleibe jetzt bei pdo und mit rowCount funktioniert es aber ohne klasse

PHP: 
if($st->rowCount() ==0)

dabei mache ich nur ein SELECT gibt es noch ne andere Möglichkeit fetchcolum oder ähnliches
 
Zuletzt bearbeitet:
Das eine Prüfung auf 0 bei einem SELECT true ergibt, dürfte klar sein. Das sagt ja auch schon die Beschreibung aus dem Manual.

Wenn du wissen willst, wieviel Rows ein SELECT zurück liefert, kannst du so vorgehen:

PHP: 
<?php
class db
{
  private $connection = NULL;
  private $results = NULL;
  private $num_rows = 0;
  private $last_error = NULL;

  public function __construct($host=NULL, $database=NULL, $user=NULL, $pass=NULL)
  {
    $this->connection = new PDO("mysql:host=".$host.";dbname=".$database, $user, $pass, array(
        PDO::ATTR_ERRMODE => PDO::ERRMODE_SILENT
    ) );
  }

  public function disconnect()
  {
    unset( $this->connection );
  }

  public function query($query)
  {
    $this->num_rows = 0;
    $result = $this->connection->query($query);
    if((int)$this->connection->errorCode())
    {
      $errinfo = $this->connection->errorInfo();
      if(count($errinfo))
        $this->last_error = $errinfo[2];
      return false;
    }
    if(preg_match('/^select/i', $query))
    {
      if($result)
      {
        if((int)$result->errorCode())
        {
          $errinfo = $result->errorInfo();
          if(count($errinfo))
            $this->last_error = $errinfo[2];
          return false;
        }
        $this->results = $result->fetchAll(PDO::FETCH_OBJ);
        $this->num_rows = count($this->results);
        return true;
      }
    }
    elseif ( preg_match('/^create/i', $query) || preg_match('/^drop/i', $query) )
    {
      if($result)
      {
        if(intval($result->errorCode()))
        {
          $errinfo = $result->errorInfo();
          if(count($errinfo))
            $this->last_error = $errinfo[2];
          return false;
        }
        return true;
      }
    }
    else
    {
      if($result)
      {
        if(intval($result->errorCode()))
        {
          $errinfo = $result->errorInfo();
          if(count($errinfo))
            $this->last_error = $errinfo[2];
          return false;
        }
        
        $this->num_rows = $result->rowCount();
        if($this->num_rows)
          return true;
      }
    }
    return false;
  }
  
  public function error()
  {
    return $this->last_error;
  }

  public function row()
  {
    $result = false;
    if( count( $this->results ) )
    {
      $result = array_shift($this->results);
    }
    return $result;
  }
  
  public function xarray()
  {
    $result = false;
    if( count( $this->results ) )
    {
      $result = (array)array_shift($this->results);
    }
    return $result;
  }

  public function numrows()
  {
    return $this->num_rows;
  }

  public function count()
  {
    return count($this->counter);
  }
}

Test-Script:

PHP: 
<?php
include './pdowrapper.class.php';

$pdowrapper = new db('127.0.0.1', 'test', 'test');

$create_table = <<<EOT
CREATE TABLE `pdowrappertest` (
    `id` INT NOT NULL AUTO_INCREMENT,
    `testcol1` VARCHAR(20),
    `testcol2` TIMESTAMP,
    PRIMARY KEY(`id`)
)
EOT;

$drop_table = <<<EOT
DROP TABLE IF EXISTS `pdowrappertest`
EOT;

$insert_some_data = <<<EOT
INSERT INTO `pdowrappertest`
    (`testcol1`, `testcol2`)
VALUES
    ('Testdaten 1', NOW()),
    ('Test daten 2', NOW()),
    ('testdat 3', NULL)
EOT;

$select_some_data = <<<EOT
SELECT * FROM `pdowrappertest` WHERE `testcol1` LIKE 'testdat%';
EOT;

if( ! $pdowrapper->query( $drop_table ) )
{
  die( $pdowrapper->error() );
}

if( ! $pdowrapper->query( $create_table ) )
{
  die( $pdowrapper->error() );
}

if( ! $pdowrapper->query( $insert_some_data ) )
{
  die( $pdowrapper->error() );
}
$insert_count = $pdowrapper->numrows();

echo "Insert-Count: " . $insert_count . "<br/>";

if( ! $pdowrapper->query( $select_some_data ) )
{
  die( $pdowrapper->error() );
}

$select_count = $pdowrapper->numrows();

echo "Select-Count: " . $select_count . "<br/>";
 
while( $row = $pdowrapper->row() )
{
  echo "<pre>";
  var_dump($row);
  echo "</pre>";  
}

if( ! $pdowrapper->query( $drop_table ) )
{
  die( $pdowrapper->error() );
}
 
Habe jetzt die Klasse von Splash integriert, jedoch wollte ich diese um eine Funktion erweitern aber es nicht so wie ich das möchte:

PHP: 
class db {
 
  private $db_obj            = null;             # Datenbank Objekt PDO 
  private $_user             = '+++++';            # Benutzername 
  private $_password         = '++++';           # Password 
  private $_datenbank        = '++++';           # Datenbankname 

  /** 
  * PDO verbindung aufbauen  * 
  */ 
  public function connect(){ 
   
    try{ 
     
      return NEW PDO ('mysql:host=localhost; dbname='.$this->_datenbank,$this->_user,$this->_password,array 
                                ( 
                                  PDO::MYSQL_ATTR_INIT_COMMAND => 'SET CHARACTER SET utf8', 
                                  PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8', 
                                  PDO::ATTR_ERRMODE            => PDO::ERRMODE_WARNING 
                                ) 
                     ); 
    } 
    catch (PDOException $e) 
    { 
      echo 'Fehler beim Öffnen der Datenbank: ' . $e->getMessage(); 
    } 

  }

  public function gab($feld,$tabelle,$where){
    
    $sql="SELECT
            ".$feld."
          FROM 
            ".$tabelle."
          WHERE 
            ".$where." ";
    $this->connect();
    $this->prepare($sql);
    $this->execute();
    $row= $this->fetch(PDO::FETCH_OBJ);
    return $row->$feld;
  } 
}

Als Fehler meldung kommt Call to a member function gab() on a non-object
den fehler habe ich gefunden jedoch sagt er nun undefinierte methode pdo::gab
 
Zuletzt bearbeitet:
Ich habe langsam das Gefühl, dir fehlen massiv die Grundlagen. Du bist noch weit davon entfernt, zu verstehen, wie PHP mit OOP arbeitet. Empfehlung: Lerne erstmal die PHP-Basics und gehe dann auf das Feld OOP zu. Danach wirst du in der Lage sein, eine PDO-Wrapper-Klasse zu schreiben.

Bis dahin solltest du dich damit abfinden und MySQLi benutzen.

Das ist echt nicht böse gemeint, ich will dir einfach die Nerven schonen. Es macht für mich nicht den Eindruck, das du das "Problem" derzeit selbständig gelöst bekommst.
 
Bin ja beriet zu lernen daran liegt es ja nicht möchte ja oop lernen ihr habt mir ja schon geholfen habe andere sachen ja hinbekommen mit mysql sprich ohne pdo nur pdo ist neuland
 
Hast du eigentlich schon mal einen Blick in die Dokumentation zu PDO geworfen? Dann könntest du die Fragen teilweise selbst beantworten. Die PDO-Schnittstelle ist nämlich wirklich seh gut dokumentiert und es existieren massig Beispiele für alle möglichen Anwendungsfälle.

Offtopic:

Ich glaube, du hast einfach Probleme, dir vorzustellen, was PDO eigentlich ist. Was ein Objekt in der Programmierung generell ist.

Es gibt eine einfache Beschreibung:

Ein Objekt ist eine Instanz einer Klasse. Eine Klasse implementiert Methoden, die Eigenschaften bearbeiten. Hier mal das klassische Autobeispiel:

Code: 
Klasse Auto
{
  private Eigenschaft marke;
  private Eigenschaft modell;
  private Eigenschaft farbe;

  private Eigenschaft benzinImTank;
  private Eigenschaft aktuellerOrt;

  öffentliche Methode herstellen()
  {
  }

  private Methode anlassen()
  {
  }

  private Methode gasGeben()
  {
      wenn( this->benzinImTank == 0 )
          werfe SpritAlleAusnahme;

      this->benzinImTank--;
  }

  öffentliche Methode fahren( Ziel )
  {
      this->anlassen();

      solange( this->aktuellerOrt != Ziel )
      {
           this->gasGeben();
      }
  }
}

Das ist jetzt echt abstrakt. Versuche den Ablauf zu verstehen, dann verstehst du auch, wie OOP funktioniert und wie PDO arbeitet. Nach etwa dem gleichen Prinzip.

Zurück zum Thema:

PDO bietet keine öffentliche Methode mit dem namen gab() an, das sagt zumindest die Fehlermeldung. In der Dokumentation ist auch keine solche Methode beschrieben. Du hast also einen Aufrufe-Fehler, und zwar an der Stelle, die in der Fehlermeldung steht (Datei + Zeile).
 
JA was Methode und Objekte sind in deinem fall ist das auto das objekt, und methode was soll damit gemacht werden tank öffnen usw und eigenschaften ob das auto bund oder klein oder sonstwas ist

Und nun zu PDO
stellt eine Scnittstelle bereit mit der man über PHP mit Datenbanken kommunizieren kann egal ob mit mysql msql man benutzt ein und den selben ja sagen wa mal (CODE/Befehle), das ist ja das genialle an PDO spart ne Menge arbeit
 
Zuletzt bearbeitet:
Naja, die Queries sind schon noch Datenbankspezifisch.
Aber auch das versucht man ja schon zu abstrahieren, siehe bspw. einen ORM...
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück