Beiträge von cottton

tabelle: `user`
id  vorname | name  
------------------
1   hans    | Wurst
2   steffan | bla
3   iknito  | usw




tabelle `user_auswahl` 
id  lieblingsessen_id | ect | ect
----------------------|-----|----
1   | 2               | 
2   | 1               | 
3   | 4               | 




tabelle `lieblingsessen`
id  | name  
-----------
1   | Wurst  
2   | Brot  
3   | Salat 
4   | Fisch

SELECT 
    *
FROM
    `user`
LEFT JOIN
    `user_auswahl` AS `essenid` 
    ON (`user`.`id` = `essenid`.`id`)
LEFT JOIN
    `lieblingsessen` AS `essen` 
    ON (`essen`.`id` = `essenid`.`id`)
WHERE
    `vorname` = 'steffan';

SELECT -- wähle aus:
    `name`, -- den namen
    COUNT(`user_wahl`.`id`) AS `Anzahl` -- und zähle die ids und nenne es (AS) `Anzahl`
FROM -- von
    `lieblingsessen` -- allen vorkommenden speisen
JOIN -- und nutze dabei die tabelle 
    `user_auswahl` AS `user_wahl` -- `user_auswahl` ALS bezeichner `user_wahl`
    ON -- wo
    -- die `lieblingsessen`.`id` gleich der `user_wahl`.`lieblingsessen_id` ist
    (`lieblingsessen`.`id` = `user_wahl`.`lieblingsessen_id`) 
WHERE -- aber nur dort wo
    `lieblingsessen_id` = 4; -- die speise die id 4 besitzt

tabelle `benutzer`
id  name   
--------
1   hans
2   dude
3   iknito




tabelle `benutzeradressen`
benutzerid  plz     ort
1           12345   dort
2           87111   hier

Tabelle1
id  Vorname | Name  
------------------
1   hans    | Wurst
2   steffan | bla
3   iknito  | usw




Tabelle2
id  Lieblingsessen 
1           wurst   
2           sülz

$x = getPage('bspseite');
/* 
in $x steck jetzt (wenn 'bspseite' gefunden/existiert) die gesuchte seite(n)
also alle datensätze auf welche "WHERE `slug` = :pagename" zutrifft
bsp:
array(
    0 => array(
        'artikel' => '...'
    )
    1 => array(
        'artikel' => '...'
    )
)
*/

// die query (das statement) wird ausgeführt:
        if(!$stmt->execute($para)){ // wenn "nicht execute", also fehler -
            // dann hier fehler handling (speichern, ausgeben, wie auch immer):
            // den fehler bekommst du via: $stmt->errorInfo()
            //  also zB var_dump($stmt->errorInfo());
            die("Fehler beim Ausführen ... [Deine Eigene mneldung hier ...]");
        }else{ // wenn das staement ausgeführt werden konnte:
            $content = $stmt->fetchAll(PDO::FETCH_ASSOC); // fetch all (hole alle)
            // return das, was du brauchst
            if(isset($content[0]["artikel"])){
                return $content[0]["artikel"];
            }
        }

// die query (das statement) wird ausgeführt:
        if(!$stmt->execute($para)){ // wenn "nicht execute", also fehler -
            // dann hier fehler handling (speichern, ausgeben, wie auch immer):
            // den fehler bekommst du via: $stmt->errorInfo()
            //  also zB var_dump($stmt->errorInfo());
            die("Fehler beim Ausführen ... [Deine Eigene mneldung hier ...]");
        }else{ // wenn das staement ausgeführt werden konnte:
            $content = $stmt->fetchAll(PDO::FETCH_ASSOC); // fetch all (hole alle) 
            return $content; 
            /*
            oder auch gleich:
            return $stmt->fetchAll(PDO::FETCH_ASSOC);
            */
        }

$content = $stmt->fetchAll(PDO::FETCH_ASSOC);
/*
$content = ~"hole alle" 
BTW:  PDO::FETCH_ASSOC ist hier neu und bewirkt assoziative arrays (also zB 'key' => 'value' anstatt 0 => 'value')
in $content steckt dann das hier:
Array
(
    [0] => Array
        (
            [artikel] => ccc
        )




)
*/

function getPage($pagename) {
        global $database_host;
        global $database_name;
        global $database_user;
        global $database_pass;
        global $database_pers; // neu und optional (persistant connection ^= bestehende verbindung)




        try{ // versuche
            $dbh = new PDO( // erzeuge neues objekt von PDO
                'mysql:host='.$database_host.';dbname='.$database_name, // verbinde zu host und datenbank
                $database_user, // mit username
                $database_pass, // und passwort
                array(PDO::ATTR_PERSISTENT => $database_pers) // und nutze parameter ... beim verbinden
            );
            }catch(PDOException $e){ // wenn "versuche" einen fehler erzeugt, dann "fange" diesen fehler in var $e
            // (wenn kein try/catch genutzt wird, dann wird das programm mit einem fatal error abgebrochen)




            // fehler ausgabe/kontrolle
            /* $e->getMessage() ^= gib mit von $e (wo der fehler "drin steckt" die meldung)
                du kannst mal testweise mit absicht ein falsches pw angeben
                und mit var_dump( $e->getMessage() ); den fehler ausgeben lassen
            */




            die ("<article>Die Artikel k&ouml;nnen nicht geladen werden, da keine Verbindung mit der Datenbank hergestellt werden konnte!</article>");
        }
        // ab hier sind wir verbunden.




        $sql = 'SELECT `artikel` FROM `aktuelles` WHERE `slug` = :pagename ORDER BY `datum` DESC LIMIT 1;';
        // :pagename ist ein platzhalter
        // LIMIT 1 (nur ein datensatz), weil du ja nur einen erwartest




        $para = array(
            ':pagename' => $pagename // hier wird der wert für den platzhalter hinterlegt
        );




        // die query wird vorbereitet:
        $stmt = $dbh->prepare($sql);




        // die query (das statement) wird ausgeführt:
        if(!$stmt->execute($para)){ // wenn "nicht execute", also fehler -
            // dann hier fehler handling (speichern, ausgeben, wie auch immer):
            // den fehler bekommst du via: $stmt->errorInfo()
            //  also zB var_dump($stmt->errorInfo());
            die("Fehler beim Ausführen ... [Deine Eigene mneldung hier ...]");
        }else{ // wenn das staement ausgeführt werden konnte:
            $content = $stmt->fetchAll(PDO::FETCH_ASSOC); // fetch all (hole alle)
            // return das, was du brauchst
            if(isset($content[0]["artikel"])){
                return $content[0]["artikel"];
            }
        }
        // wenn wir hier sind, haben wir noch nicht "returned", also keine daten.
        return false;
        }

function getPage($pagename) {
    global $database_host;
    global $database_name;
    global $database_user;
    global $database_pass;
    global $database_pers; // neu und optional (persistant connection ^= bestehende verbindung)




    try{ // versuche
        $dbh = new PDO( // erzeuge neues objekt von PDO
            'mysql:host='.$database_host.';dbname='.$database_name, // verbinde zu host und datenbank
            $database_user, // mit username
            $database_pass, // und passwort
            array(PDO::ATTR_PERSISTENT => $database_pers) // und nutze parameter ... beim verbinden
        );
        }catch(PDOException $e){ // wenn "versuche" einen fehler erzeugt, dann "fange" diesen fehler in var $e
        // (wenn kein try/catch genutzt wird, dann wird das programm mit einem fatal error abgebrochen)




        // fehler ausgabe/kontrolle
        /* $e->getMessage() ^= gib mit von $e (wo der fehler "drin steckt" die meldung)
            du kannst mal testweise mit absicht ein falsches pw angeben
            und mit var_dump( $e->getMessage() ); den fehler ausgeben lassen
        */




        die ("<article>Die Artikel k&ouml;nnen nicht geladen werden, da keine Verbindung mit der Datenbank hergestellt werden konnte!</article>");
    }   
    // ab hier sind wir verbunden.
 
    $sql = 'SELECT `artikel` FROM `aktuelles` WHERE `slug` = :pagename ORDER BY `datum` DESC LIMIT 1;'; 
    // :pagename ist ein platzhalter
    // LIMIT 1 (nur ein datensatz), weil du ja nur einen erwartest




    $para = array(
        ':pagename' => $pagename // hier wird der wert für den platzhalter hinterlegt 
    );




    // die query wird vorbereitet: 
    $stmt = $dbh->prepare($sql); 




    // die query (das statement) wird ausgeführt:
    if(!$stmt->execute($para){ // wenn "nicht execute", also fehler -
        // dann hier fehler handling (speichern, ausgeben, wie auch immer):
        var_dump($stmt->errorInfo());
        die;
    }else{ // wenn das staement ausgeführt werden konnte:
        $content = $stmt->fetchAll(); // fetch all (hole alle) 
        // return das, was du brauchst
        return $table["artikel"];
    }
    // wenn wir hier sind, haben wir noch nicht "returned", also keine daten.
    return false;
}

// Sql.php
<?php 
class Sql
{
    private static $dbh;




    final public static function connect($host=false,$username=false,$password=false,$pers_con=false)
    {
        // $host = host [string] ...
        // $username = [string] ...
        // $password =  [string] ...
        // $pers_con = [bool] siehe http://www.php.net/manual/de/pdo.connections.php "Beispiel #4 Persistente Verbindungen"




        // verbindung herstellen:
        try{
            self::$dbh = new PDO(
                'mysql:host='.$host,
                $username,
                $password,
                array(PDO::ATTR_PERSISTENT => $pers_con)
            );
            return true;
        }catch(PDOException $e){
            throw new Exception($e->getMessage());
        }
    }
    final public static function exe($sql=null,$para=null,$bind_para=false)
    {
        // $sql = [string] die query. zb "SELECT * FROM `tabelle` WHERE `name` = :name;"
        // $para = [array] parameter wie zb array( ':name' => 'Hans' )
        // $bind_para = [bool] siehe http://de3.php.net/manual/de/pdostatement.bindparam.php




        $stmt = self::$dbh->prepare($sql);




        if($bind_para and is_array($para)){
            foreach($para as $key => &$val){
                if(is_string($val)){
                    $stmt->bindParam($key,$val,PDO::PARAM_STR);
                }elseif(is_bool($val)){
                    $stmt->bindParam($key,$val,PDO::PARAM_BOOL);
                }elseif(is_null($val)){
                    $stmt->bindParam($key,$val,PDO::PARAM_NULL);
                }elseif(is_numeric($val)){
                    $stmt->bindParam($key,$val,PDO::PARAM_INT);
                }
            }
            $para=null;
        }




        $result = null;
        if(!$stmt->execute(($para)?$para:null)){
            $err_info = $stmt->errorInfo();
            throw new Exception(
                '(SQLSTATE: '.$err_info[0].') '.$err_info[2].' -- Query: '.$sql
            );
        }else{
            while($row = $stmt->fetch(PDO::FETCH_ASSOC)){
                $result[] = $row;
            }
        }




        $stmt = null;
        return $result;
    }
    final public static function PDObeginTransaction()
    {
        return self::$dbh->beginTransaction();
    }
    final public static function PDOcommit()
    {
        return self::$dbh->commit();
    }
    public static function PDOrollBack()
    {
        return self::$dbh->rollBack();
    }
    final public static function PDOlastInsertId()
    {
        return self::$dbh->lastInsertId();
    }
} 
?>

<?php
require_once 'Sql.php';




try{
    // verbindung aufbauen:
    Sql::connect('localhost','myusername','mypassword',true);




    // optional aber ich empfehle es:
    Sql::exe("SET sql_mode = 'STRICT_ALL_TABLES';"); // http://dev.mysql.com/doc/refman/5.1/de/constraint-invalid-data.html
    Sql::exe("USE `mydb`;");
}catch(Exception $e){
    // error handling
    die($e->getMessage());
}




// query:
$sql = "SELECT `id`,`name` FROM `mydb`.`mytable` WHERE `name` = :name ORDER BY `id` DESC LIMIT :start,:max";




// parameter:
$para = array(
    ':name' => 'hans'
    ':start' => 0
    ':max' => 100
);




/*info:
    bei nutzung von "LIMIT :start,:max" wird ->bindParam() benötigt
    daher beim abfeuern Sql::exe($sql,$para,true) -- also TRUE als 3ten parameter mitgeben
*/




// "einfach ausführen" =)
$daten = Sql::exe($sql,$para,true);




var_dump($daten);







/* wichtig:
    PDO unterstützt keine "multi-queries"!
    heißt - das hier ist falsch:
    $sql = "
        SELECT * FROM `tblansprechpartner` WHERE `Vorname` = :vorname;
        SELECT * FROM `tblansprechpartner` WHERE `Vorname` = :vorname;
        SELECT * FROM `tblansprechpartner` WHERE `Vorname` = :vorname;
    ";
    richtig wäre zb ->beginTransaction, ->commit und ->rollBack zu nutzen und jede query einzelln abzufeuern
*/
?>

$DB['host'] = '';
$DB['user'] = '';
$DB['password'] = '';
$DB['pers_con'] = 1; 







// verbindung herstellen:
try{
    $dbh = new PDO('mysql:host='.$DB['host'],$DB['user'],$DB['password'],array(PDO::ATTR_PERSISTENT => $DB['pers_con'])); 
}catch(PDOException $e){
    // error handling
    die($e->getMessage());
}




// query:
$sql = "SELECT `artikel` FROM `aktuelles` WHERE `slug` = :pagename ORDER BY `dasNachDemDuSortierenWillst`ASC;"; // :pagename ist ein platzhalter
$para = array(
    ':pagename' => $pagename
);




// prepare query:
$stmt = $dbh->prepare($sql);




// ausführen und evtl fehler abfangen: 
if(!$stmt->execute(($para)?$para:null)){
    var_dump($stmt->errorInfo());
    die;
}else{ 
    while($row = $stmt->fetch(PDO::FETCH_ASSOC)){
        var_dump($row);
    }
}