Queries in een php class
Waarom kan dit niet?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?php
include_once('databaseclass.php');
class user {
private $query = mysqli_query($database->connect(),"SELECT * FROM users WHERE login_hash = '".$_SESSION['user_hash']."' LIMIT 1");
private $query_array = mysqli_fetch_array($query);
}
?>
include_once('databaseclass.php');
class user {
private $query = mysqli_query($database->connect(),"SELECT * FROM users WHERE login_hash = '".$_SESSION['user_hash']."' LIMIT 1");
private $query_array = mysqli_fetch_array($query);
}
?>
Ik krijg deze error:
Parse error: syntax error, unexpected '(', expecting ',' or ';' in C:\xampp\htdocs\php_forum\imports\classes\userclass.php on line 7
Gewijzigd op 06/04/2015 13:13:24 door - Ariën -
Quote:
Class member variables are called "properties". You may also see them referred to using other terms such as "attributes" or "fields", but for the purposes of this reference we will use "properties". They are defined by using one of the keywords public, protected, or private, followed by a normal variable declaration. This declaration may include an initialization, but this initialization must be a constant value--that is, it must be able to be evaluated at compile time and must not depend on run-time information in order to be evaluated.
Hoe je dit wel kunt doen is zo:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
include_once('databaseclass.php');
class user {
private $query;
private $query_array;
public function __construct()
{
$this->query = //... assign je value;
$this->query_array = //... assign je value;
}
}
?>
include_once('databaseclass.php');
class user {
private $query;
private $query_array;
public function __construct()
{
$this->query = //... assign je value;
$this->query_array = //... assign je value;
}
}
?>
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
include_once('databaseclass.php');
class user {
private $query;
private $query_array;
public function __construct() {
$this->query = mysqli_query($database->connect(),"SELECT * FROM users WHERE login_hash = '".$_SESSION['user_hash']."' LIMIT 1");
$this->query_array = mysqli_fetch_array($query);
}
?>
include_once('databaseclass.php');
class user {
private $query;
private $query_array;
public function __construct() {
$this->query = mysqli_query($database->connect(),"SELECT * FROM users WHERE login_hash = '".$_SESSION['user_hash']."' LIMIT 1");
$this->query_array = mysqli_fetch_array($query);
}
?>
En nu krijg ik deze errors:
Notice: Undefined variable: database in C:\xampp\htdocs\php_forum\imports\classes\userclass.php on line 11
Fatal error: Call to a member function connect() on a non-object in C:\xampp\htdocs\php_forum\imports\classes\userclass.php on line 11
Hij herkent op een een of andere manier de $database variabele niet die zich in 'databaseclass.php' bevindt.
Volgens mij heb jedeze niet als databaseclass geinitialiseerd, dan kan je hem ook niet als zodanig gebruiken.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
class database {
function connect() {
$mysql_host = "localhost";
$mysql_user = "root";
$mysql_password = "";
$mysql_database = "database";
$db_connection = mysqli_connect($mysql_host,$mysql_user,$mysql_password,$mysql_database);
if($db_connection) {
return $db_connection;
exit;
} else {
die("Couldn't connect to the database");
}
}
}
$database = new database();
?>
class database {
function connect() {
$mysql_host = "localhost";
$mysql_user = "root";
$mysql_password = "";
$mysql_database = "database";
$db_connection = mysqli_connect($mysql_host,$mysql_user,$mysql_password,$mysql_database);
if($db_connection) {
return $db_connection;
exit;
} else {
die("Couldn't connect to the database");
}
}
}
$database = new database();
?>
Is dit trouwens een goede manier om te verbinden met de database of kan het beter?
Als je van object A (van klasse A) gebruik wilt maken in object B (van klasse B), dan moet op een of andere manier object A bekend zijn bij object B. Je zou dit bijvoorbeeld kunnen bereiken door bij creatie een referentie van object A aan object B door te geven:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
// *** declaratie ***
// NB: namen van classes zouden met een Hoofdletter moeten beginnen
class User
{
protected $db;
public function __construct($db) {
$this->db = $db;
}
// na creatie van een object van deze klasse kun je in je methoden
// gebruik maken van je database via $this->db
}
// *** aanroep ***
// creatie database object
$db = new Database(...);
// creatie user object
$user = new User($db);
?>
// *** declaratie ***
// NB: namen van classes zouden met een Hoofdletter moeten beginnen
class User
{
protected $db;
public function __construct($db) {
$this->db = $db;
}
// na creatie van een object van deze klasse kun je in je methoden
// gebruik maken van je database via $this->db
}
// *** aanroep ***
// creatie database object
$db = new Database(...);
// creatie user object
$user = new User($db);
?>
Quote:
Is dit trouwens een goede manier om te verbinden met de database of kan het beter?
Dit kan (stukken) beter, want deze class heeft op dit moment geen toegevoegde waarde. De parameters waarmee je een verbinding maakt zijn hard gecodeerd, wat de klasse niet herbruikbaar maakt. Daarnaast wordt er geen character encoding geselecteerd bij het maken van de connectie wat een bron van veel ellende is. Ook bevat de klasse geen verdere (shorthand) methoden voor het uitvoeren van queries, het escapen van DATA binnen je SQL, het starten, committen en terugdraaien van transacties, het ophalen van resultaten (waar je een aparte klasse aan zou moeten wijden) of insert-id's en eventueel het bijhouden van statistieken (als je dat leuk vindt).
Het gebruik van klasses zou je (op den duur) werk uit handen moeten nemen en taken eenvoudiger moeten maken. De bovenstaande database-klasse doet dit niet.
Gewijzigd op 04/04/2015 15:46:04 door Thomas van den Heuvel
Een bijkomend voordeel daarvan (het gebruik maken van bouwstenen) is dat je dingen ook elke keer op precies dezelfde manier aanpakt. Als je je code elke keer helemaal opnieuw uitschrijft heb je die garantie niet. En als je dan toch elke keer alles knipt en plakt kun je er beter voor zorgen dat je dezelfde (en één) bron gebruikt niet?
En nog een voordeel is is dat je het maar 1x hoeft uit te denken en je kunt het daarna (zonder al teveel na te denken) gebruiken. Dan hoef je er ook maar 1x voor te zorgen dat je een aanroep van mysqli_set_charset() (of de OOP-variant daarvan) niet vergeet :).
Je zou eerst een (abstracte) Database klasse kunnen maken waarin je definieert wat je wilt kunnen doen met deze klasse, zoals:
- het opbouwen van een connectie (kun je in de __construct() regelen)
hierbij zou je uit kunnen gaan van enkele default waarden voor bepaalde instellingen zoals host, poort en character encoding (waarvan je wel kunt afwijken als je afwijkende instellingen hebt maar standaard hoef je niets extra's hiervoor te doen)
- het uitvoeren van een query (doh)
- het starten, committen en rollbacken van transacties (als je database engine dit ondersteunt)
- het ophalen van het laatst toegevoegde auto-increment id
- het ophalen van het aantal "affected" records na uitvoering van een query
Nu zou je zeggen: "waarom zou ik hiervoor een database klasse moeten maken, deze functies / methoden zijn er al in native PHP".
Deze opzet heeft één belangrijk voordeel: je koppelt het aanspreken van je database los van database-specifieke functies, of liever gezegd, je maakt indirect gebruik van deze database-specifieke functies. Dit is eigenlijk precies wat PDO doet.
Ik ga er een beetje stilzwijgend vanuit dat je gebruik maakt van een MySQL-database, en dat je hiermee wilt communiceren via MySQLi-functies of -methoden die je wilt organiseren in een Database klasse. Dit kan, maar er is dus ook een alternatief: PDO. Beide oplossingen hebben voor- en nadelen. Zo is PDO niet specifiek geshreven voor een specifieke database (en dus ook niet voor MySQL), en als je enkel MySQL-databases gebruikt kun je net zo goed MySQLi gebruiken. Als je PDO gebruikt voor communicatie met je MySQL-database dan zul je je enigszins moeten verdiepen in de werking van de PDO_MySQL driver.
Iets wat beide varianten niet oplossen is een abstractie van de SQL; beide varianten (PDO of je eigen database-toegang-abstractie-laag) bieden een uniforme manier om met je database te communiceren maar de onderliggende SQL die je in beide varianten gebruikt is nog steeds database-specifiek. Als je een nog verdere abstractie wilt zul je een soort van data-abstractie-laag moeten realiseren, bijvoorbeeld door middel van Object Relational Mapping (als ik het goed heb?).
Maar goed, terug naar het eerdere genoemde voordeel.
Stel je hebt deze verouderde code met mysql_query aanroepen:
some_code.php
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
<?php
// do stuff
$res = mysql_query(<stuff>);
while ($row = mysql_fetch_assoc($res)) {
<do stuff>
}
// ...
$res = mysql_query(<more stuff>);
while ($row = mysql_fetch_assoc($res)) {
<do more stuff>
}
?>
// do stuff
$res = mysql_query(<stuff>);
while ($row = mysql_fetch_assoc($res)) {
<do stuff>
}
// ...
$res = mysql_query(<more stuff>);
while ($row = mysql_fetch_assoc($res)) {
<do more stuff>
}
?>
Wat nu als je op een gegeven moment besluit dat je wilt overstappen naar MySQLi. Een hele "eenvoudige" manier zou zijn: doe een search-and-replace door heel je code op alle mysql_ functies.
Maar wat als je deze mysql_ functies nou al in een database-klasse had gevangen? Dan hoef je niet alle code aan te passen in alle verschillende bestanden maar enkel de implementatie van deze klasse te veranderen. Als alle methoden van de klasse goed omschreven zijn zou dit redelijk eenvoudig bewerkstelligd kunnen worden. Dit is veel minder werk en veel minder foutgevoeling omdat je je "definities" maar op één plek aanpast. Het probleem wat je hiermee dus voorkomt is hardcoding van database-specifieke functies overal in je code.
Uiteraard kom je voor hele andere problemen te staan als je naar een andere database overstapt...
Zoals gezegd: nadat je in je abstracte klasse hebt bedacht wat voor functionaliteit je wilt hebben (nog even los van hoe je dit doet dus) schrijf je vervolgens een klasse die hiervan afgeleid is en een database-(driver-)specifieke implementatie geeft van je abstracte klasse. Hier stop je dus het hoe in en geef je precies aan hoe de abstracte methoden afgehandeld zouden moeten worden.
Op eenzelfde wijze zou je ook een abstracte klasse (of interface) kunnen definieren voor een result-set. Hier definieer je welke methoden je verwacht bij implementaties van die klasse (dit is dus in feite ook een specificatie van wat je wilt kunnen doen met een result-set, bijvoorbeeld:
- het ophalen van een resultaatrij
ik gebruik hierbij enkel fetch_assoc, ik ben niet geinteresseerd in andere varianten
- het ophalen van een enkele kolom
als handige shorthand
- het teruggeven van het aantal resultaatrijen
- het "scrollen" naar een specifiek resultaat (dataSeek)
- het vrijgeven van een resultaat
Na de declaraties van je abstracte klasses implementeer je deze bijvoorbeeld met MySQLi, je krijgt dan zoiets:
Database klasse
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
abstract class Database
{
protected $connection;
protected $transactionStarted;
abstract public function __construct($username, $password, $database, $settings=array());
abstract public function escape($input);
abstract public function query($query);
abstract public function startTransaction();
abstract public function commitTransaction();
abstract public function rollbackTransaction();
abstract public function insertId();
abstract public function affectedRows();
}
?>
abstract class Database
{
protected $connection;
protected $transactionStarted;
abstract public function __construct($username, $password, $database, $settings=array());
abstract public function escape($input);
abstract public function query($query);
abstract public function startTransaction();
abstract public function commitTransaction();
abstract public function rollbackTransaction();
abstract public function insertId();
abstract public function affectedRows();
}
?>
Database Result klasse
Code (php)
En de implementaties:
Database MySQLi klasse
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
<?php
class Database_MySQLi extends Database
{
protected static $queryCount;
public function __construct($username, $password, $database, $settings=array()) {
// Default settings are overridden by $settings.
$settings = $settings + array(
'host' => '127.0.0.1',
'port' => '3306',
'charset' => 'utf8',
);
$this->connection = new MySQLi($settings['host'], $username, $password, $database, $settings['port']);
if ($this->connection->connect_error) {
// @todo throw exception instead?
die('[error] '.$this->connection->connect_errno.', '.$this->connection->connect_error);
}
if (!$this->connection->set_charset($settings['charset'])) {
// @todo throw exception instead?
die('[error] failed to set charset: '.$this->connection->error);
}
$this->transactionStarted = false;
self::$queryCount = 0;
}
public function escape($input) {
return $this->connection->real_escape_string($input);
}
public function query($query) {
if ($this->connection->real_query($query)) {
self::$queryCount++;
return new Database_Result_MySQLi($this->connection);
} else {
// Note that the text that the error returns may contain data provided by the user, so it should be escaped.
throw new Exception($this->connection->error."\n".$query);
}
}
public function startTransaction() {
if ($this->transactionStarted) {
throw new Exception('transaction already running');
} else {
$this->connection->autocommit(false);
$this->transactionStarted = true;
register_shutdown_function(array($this, 'shutdownCheck'));
}
}
public function shutdownCheck() {
if ($this->transactionStarted) {
$this->rollbackTransaction();
}
}
public function commitTransaction() {
// Commit pending queries.
$this->connection->commit();
// The next line both commits queries in queue (the transaction) and turns autocommit back on.
// Note that with the addition of commit() it no longer commits any pending queries (as there are none).
$this->connection->autocommit(true);
$this->transactionStarted = false;
}
public function rollbackTransaction($stopTransaction=true) {
$this->connection->rollback();
if ($stopTransaction) {
// Afterwards, turn back on autocommitting.
// It is up to the user to decide whether (s)he wants to continue after a rollback though...
$this->connection->autocommit(true);
$this->transactionStarted = false;
}
}
public function insertId() {
return $this->connection->insert_id;
}
public function affectedRows() {
return $this->connection->affected_rows;
}
public function getQueryCount() {
return self::$queryCount;
}
}
?>
class Database_MySQLi extends Database
{
protected static $queryCount;
public function __construct($username, $password, $database, $settings=array()) {
// Default settings are overridden by $settings.
$settings = $settings + array(
'host' => '127.0.0.1',
'port' => '3306',
'charset' => 'utf8',
);
$this->connection = new MySQLi($settings['host'], $username, $password, $database, $settings['port']);
if ($this->connection->connect_error) {
// @todo throw exception instead?
die('[error] '.$this->connection->connect_errno.', '.$this->connection->connect_error);
}
if (!$this->connection->set_charset($settings['charset'])) {
// @todo throw exception instead?
die('[error] failed to set charset: '.$this->connection->error);
}
$this->transactionStarted = false;
self::$queryCount = 0;
}
public function escape($input) {
return $this->connection->real_escape_string($input);
}
public function query($query) {
if ($this->connection->real_query($query)) {
self::$queryCount++;
return new Database_Result_MySQLi($this->connection);
} else {
// Note that the text that the error returns may contain data provided by the user, so it should be escaped.
throw new Exception($this->connection->error."\n".$query);
}
}
public function startTransaction() {
if ($this->transactionStarted) {
throw new Exception('transaction already running');
} else {
$this->connection->autocommit(false);
$this->transactionStarted = true;
register_shutdown_function(array($this, 'shutdownCheck'));
}
}
public function shutdownCheck() {
if ($this->transactionStarted) {
$this->rollbackTransaction();
}
}
public function commitTransaction() {
// Commit pending queries.
$this->connection->commit();
// The next line both commits queries in queue (the transaction) and turns autocommit back on.
// Note that with the addition of commit() it no longer commits any pending queries (as there are none).
$this->connection->autocommit(true);
$this->transactionStarted = false;
}
public function rollbackTransaction($stopTransaction=true) {
$this->connection->rollback();
if ($stopTransaction) {
// Afterwards, turn back on autocommitting.
// It is up to the user to decide whether (s)he wants to continue after a rollback though...
$this->connection->autocommit(true);
$this->transactionStarted = false;
}
}
public function insertId() {
return $this->connection->insert_id;
}
public function affectedRows() {
return $this->connection->affected_rows;
}
public function getQueryCount() {
return self::$queryCount;
}
}
?>
Database Result MySQLi klasse
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<?php
class Database_Result_MySQLi extends MySQLi_Result implements Database_Result
{
// Returns an associative array.
public function fetchRow() {
return $this->fetch_assoc();
}
// Returns a single value (first column of current row), for COUNT queries and such.
// If it is not guaranteed a query has (at least) one result, YOU need to check for this yourself.
// Here we assume the query does have at least one result.
// return $this->fetch_row()[0] seems slightly faster, requires PHP 5.4 or later
// @see https://wiki.php.net/rfc/functionarraydereferencing (FAD)
public function fetchValue() {
$row = $this->fetch_row();
return $row[0];
}
public function numRows() {
return $this->num_rows;
}
public function dataSeek($offset=0) {
return $this->data_seek($offset);
}
public function freeResult() {
$this->free();
}
}
?>
class Database_Result_MySQLi extends MySQLi_Result implements Database_Result
{
// Returns an associative array.
public function fetchRow() {
return $this->fetch_assoc();
}
// Returns a single value (first column of current row), for COUNT queries and such.
// If it is not guaranteed a query has (at least) one result, YOU need to check for this yourself.
// Here we assume the query does have at least one result.
// return $this->fetch_row()[0] seems slightly faster, requires PHP 5.4 or later
// @see https://wiki.php.net/rfc/functionarraydereferencing (FAD)
public function fetchValue() {
$row = $this->fetch_row();
return $row[0];
}
public function numRows() {
return $this->num_rows;
}
public function dataSeek($offset=0) {
return $this->data_seek($offset);
}
public function freeResult() {
$this->free();
}
}
?>
De toegevoegde waarde is vervolgens ook de hoeveelheid code die je (minder) moet kloppen bij gebruikmaking van deze klasses, de definities zijn korter (en regelen soms meer dingen tegelijkertijd op de achtergrond) dan wanneer je dit elke keer helemaal uitschrijft.
Dit is mijn "wiel", veel plezier met het maken van je eigen wiel.
Gewijzigd op 06/04/2015 18:13:08 door Thomas van den Heuvel
Toevoeging op 07/04/2015 13:26:58:
Al begrijp ik nog lang niet alles :P