PDO sınıfı

(PHP 5 >= 5.1.0, PHP 7, PECL pdo >= 0.1.0)

Giriş

PHP ile bir veritabanı sunucusu arasındaki bağlantıyı temsil eder.

Sınıf Sözdizimi

PDO {
__construct ( string $dsn [, string $kullanıcı [, string $parola [, array $seçenekler ]]] )
bool beginTransaction ( void )
bool commit ( void )
mixed errorCode ( void )
array errorInfo ( void )
int exec ( string $deyim )
mixed getAttribute ( int $öznitelik )
array getAvailableDrivers ( void )
public bool inTransaction ( void )
string lastInsertId ([ string $isim = NULL ] )
PDOStatement prepare ( string $deyim [, array $seçenekler = array() ] )
PDOStatement query ( string $deyim )
string quote ( string $dizge [, int $değiştirge_türü = PDO::PARAM_STR ] )
bool rollBack ( void )
bool setAttribute ( int $öznitelik , mixed $değer )
}

İçindekiler

  • PDO::beginTransaction — Bir toplu hareketi ilklendirir
  • PDO::commit — Bir toplu hareketi veritabanına gönderir
  • PDO::__construct — Bir veritabanı bağlantısını temsil eden bir PDO nesnesi oluşturur
  • PDO::errorCode — Veritabanındaki son işlemle ilgili SQLSTATE kodunu döndürür
  • PDO::errorInfo — Veritabanındaki son işlemle ilgili hata bilgisini döndürür
  • PDO::exec — Belirtilen SQL deyimini çalıştırır ve etkilenen satır sayısını döndürür
  • PDO::getAttribute — Bir veritabanı bağlantı özniteliğinin değerini döndürür
  • PDO::getAvailableDrivers — Kullanılabilen PDO sürücülerini içeren bir dizi döndürür
  • PDO::inTransaction — Checks if inside a transaction
  • PDO::lastInsertId — Son yerleştirilen satırın veya sıradaki değerin kimliğini döndürür
  • PDO::prepare — Çalıştırılmak üzere bir deyimi hazırlar ve bir deyim nesnesi olarak döndürür
  • PDO::query — Bir SQL deyimini çalıştırıp sonucu bir PDOStatement nesnesi olarak döndürür
  • PDO::quote — Bir sorguda kullanılmak üzere bir dizgeyi önceler
  • PDO::rollBack — Bir toplu hareketi geri alır
  • PDO::setAttribute — Bir öznitelik tanımlar
add a note add a note

User Contributed Notes 10 notes

up
62
Megaloman
8 years ago
"And storing username/password inside class is not a very good idea for production code."

Good idea is to store database connection settings in *.ini files but you have to restrict access to them. For example this way:

my_setting.ini:
[database]
driver = mysql
host = localhost
;port = 3306
schema = db_schema
username = user
password = secret

Database connection:
<?php
class MyPDO extends PDO
{
    public function
__construct($file = 'my_setting.ini')
    {
        if (!
$settings = parse_ini_file($file, TRUE)) throw new exception('Unable to open ' . $file . '.');
       
       
$dns = $settings['database']['driver'] .
       
':host=' . $settings['database']['host'] .
        ((!empty(
$settings['database']['port'])) ? (';port=' . $settings['database']['port']) : '') .
       
';dbname=' . $settings['database']['schema'];
       
       
parent::__construct($dns, $settings['database']['username'], $settings['database']['password']);
    }
}
?>

Database connection parameters are accessible via human readable ini file for those who screams even if they see one PHP/HTML/any_other command.
up
10
williambarry007 at gmail dot com
6 years ago
PDO and Dependency Injection

Dependency injection is good for testing.  But for anyone wanting various data mapper objects to have a database connection, dependency injection can make other model code very messy because database objects have to be instantiated all over the place and given to the data mapper objects.

The code below is a good way to maintain dependency injection while keeping clean and minimal model code.

<?php

class DataMapper
{
    public static
$db;
   
    public static function
init($db)
    {
       
self::$db = $db;
    }
}

class
VendorMapper extends DataMapper
{
    public static function
add($vendor)
    {
       
$st = self::$db->prepare(
           
"insert into vendors set
            first_name = :first_name,
            last_name = :last_name"
       
);
       
$st->execute(array(
           
':first_name' => $vendor->first_name,
           
':last_name' => $vendor->last_name
       
));
    }
}

// In your bootstrap
$db = new PDO(...);
DataMapper::init($db);

// In your model logic
$vendor = new Vendor('John', 'Doe');
VendorMapper::add($vendor);

?>
up
8
anrdaemon at freemail dot ru
9 years ago
Keep in mind, you MUST NOT use 'root' user in your applications, unless your application designed to do a database maintenance.

And storing username/password inside class is not a very good idea for production code. You would need to edit the actual working code to change settings, which is bad.
up
8
kcleung at kcleung dot no-ip dot org
7 years ago
Here is an singleton PDO example:

###### config.ini ######
db_driver=mysql
db_user=root
db_password=924892xp

[dsn]
host=localhost
port=3306
dbname=localhost

[db_options]
PDO::MYSQL_ATTR_INIT_COMMAND=set names utf8

[db_attributes]
ATTR_ERRMODE=ERRMODE_EXCEPTION
############

<?php class Database {
    private static
$link = null ;

    private static function
getLink ( ) {
        if (
self :: $link ) {
            return
self :: $link ;
        }

       
$ini = _BASE_DIR . "config.ini" ;
       
$parse = parse_ini_file ( $ini , true ) ;

       
$driver = $parse [ "db_driver" ] ;
       
$dsn = "${driver}:" ;
       
$user = $parse [ "db_user" ] ;
       
$password = $parse [ "db_password" ] ;
       
$options = $parse [ "db_options" ] ;
       
$attributes = $parse [ "db_attributes" ] ;

        foreach (
$parse [ "dsn" ] as $k => $v ) {
           
$dsn .= "${k}=${v};" ;
        }

       
self :: $link = new PDO ( $dsn, $user, $password, $options ) ;

        foreach (
$attributes as $k => $v ) {
           
self :: $link -> setAttribute ( constant ( "PDO::{$k}" )
                ,
constant ( "PDO::{$v}" ) ) ;
        }

        return
self :: $link ;
    }

    public static function
__callStatic ( $name, $args ) {
       
$callback = array ( self :: getLink ( ), $name ) ;
        return
call_user_func_array ( $callback , $args ) ;
    }
}
?>

<?php // examples
$stmt = Database :: prepare ( "SELECT 'something' ;" ) ;
$stmt -> execute ( ) ;
var_dump ( $stmt -> fetchAll ( ) ) ;
$stmt -> closeCursor ( ) ;
?>
up
5
thz at plista dot com
4 years ago
Starting with PHP 5.4 you are unable to use persistent connections when you have your own database class derived from the native PDO class. If your code uses this combination, you will encounter segmentation faults during the cleanup of the PHP process.
You can still use _either_ a derived PDO class _or_ persistent connections.

For more information, please see this bug report: https://bugs.php.net/bug.php?id=63176
up
0
sinri at everstray dot com
6 days ago
For some Database Environment, such as Aliyun DRDS (Distributed Relational Database Service), cannot process preparing for SQL.
For such cases, the option `\PDO::ATTR_EMULATE_PREPARES` should be set to true. If you always got reports about "Failed to prepare SQL" while this option were set to false, you might try to turn on this option to emulate prepares for SQL.
up
-6
schizo_mind at hotmail dot com
9 years ago
<?php
class PDOConfig extends PDO {
   
    private
$engine;
    private
$host;
    private
$database;
    private
$user;
    private
$pass;
   
    public function
__construct(){
       
$this->engine = 'mysql';
       
$this->host = 'localhost';
       
$this->database = '';
       
$this->user = 'root';
       
$this->pass = '';
       
$dns = $this->engine.':dbname='.$this->database.";host=".$this->host;
       
parent::__construct( $dns, $this->user, $this->pass );
    }
}
?>
up
-7
rumsg at mail dot ru
2 years ago
$DB = new PDO('mysql:host=127.0.0.1;port=3306;dbname=anexis_new;charset=UTF8;','root','password', array(PDO::ATTR_PERSISTENT=>true));
$DB->query("SET NAMES utf8;");
up
-2
Anonymous
3 months ago
I personnaly create a new instance of PDO like this :

$dbDatas = parse_ini_file( DB_FILE );
$dbOptions = [
\PDO::ATTR_DEFAULT_FECTH_MODE => \PDO::FETCH_OBJ,
\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION
];

$dsn = sprintf( 'mysql:dbname=%s;host=%s', $dbDatas['dbname'],
$dbDatas['host'] );

$this->cn = new \PDO( $dsn, $dbDatas['user'], $dbDatas['password'],
$dbOptions );
$this->cn->exec( 'SET CHARACTER SET UTF8' );
up
-26
sideshowAnthony at googlemail dot com
2 years ago
Here is a cheeky PDO helper class to get you started . . .

define('DB_MAIN', 'localhost|user1|pa55word|db1');

// Connect to database db1
$db = new my_db(DB_MAIN);

// Request "SELECT * FROM table1 WHERE a=16 AND b=22"
// Get an array of stdClass's
$rows = $db->fetchAll('SELECT * FROM table1 WHERE a=? AND b=?', 16, 22);

class my_db{

    private static $databases;
    private $connection;

    public function __construct($connDetails){
        if(!is_object(self::$databases[$connDetails])){
            list($host, $user, $pass, $dbname) = explode('|', $connDetails);
            $dsn = "mysql:host=$host;dbname=$dbname";
            self::$databases[$connDetails] = new PDO($dsn, $user, $pass);
        }
        $this->connection = self::$databases[$connDetails];
    }
   
    public function fetchAll($sql){
        $args = func_get_args();
        array_shift($args);
        $statement = $this->connection->prepare($sql);       
        $statement->execute($args);
         return $statement->fetchAll(PDO::FETCH_OBJ);
    }
}
To Top