Mysql connection class
Ik heb doormiddel van tuts een connectie class gemaakt.
Doe ik het zo goed, op deze manier?
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
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
class MySQL
{
private $_host;
private $_username;
private $_password;
private $_db;
private $_conn;
public function __construct($host, $user, $pass, $db)
{
$this->_host = $host;
$this->_username = $name;
$this->_password = $pass;
$this->_db = $db;
}
public function connect()
{
$this->_conn = mysql_connect($this->_host, $this->_username, $this->_password);
if(!$this->_conn)
{
return mysql_error();
}
}
}
{
private $_host;
private $_username;
private $_password;
private $_db;
private $_conn;
public function __construct($host, $user, $pass, $db)
{
$this->_host = $host;
$this->_username = $name;
$this->_password = $pass;
$this->_db = $db;
}
public function connect()
{
$this->_conn = mysql_connect($this->_host, $this->_username, $this->_password);
if(!$this->_conn)
{
return mysql_error();
}
}
}
Maar ben ik zo goed op weg?
Verder kan je eens naar pdo en mysqli kijken.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ILoran punt NL op 08/10/2010 23:06:49:
Miss heb je hier iets aan:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Gatver-tyfus-damme. WTF moet deze onzin voortellen?
- Functie om klasse heenschrijven? Gebruik dan geen klasse.
- Global? Global is vies, weg met global.
- Waarom kan je niet gewoon mysqli aanroepen, kan je gewoon $link gebruiken.
- Procedurale ondersteuning van mysqli is er alleen voor om te zorgen dat oudere php versies ook mysqli kunnen gebruiken. Waarom heb je dus niet gewoon de standaard OO manier gebruikt?
- NOOIT de fout die mysql teruggeeft aan de gebruiker weergeven. Alleen gebruiken voor debuggen.
- GA ZELF DOOD NEER VALLEN!
Waar slaat jouw reactie op?
Heel toevallig stond het zo in mijn schoolboek.....
Helaas wel!
"- GA ZELF DOOD NEER VALLEN!"
DOE NORMAAL!
Youri van Mill op 08/10/2010 14:39:33:
Ik ben nieuw in OOP.
Doe ik het zo goed, op deze manier?
Doe ik het zo goed, op deze manier?
Het werkt, dus je doet het niet heel fout. Maar waarom sla je de gebruikersnaam op in een member-variabele? Nadat je een verbinding hebt gemaakt, heb je die toch niet meer nodig?
Op zich is het niet nuttig om voor MySQL een class te maken, die zijn er al. PHP Heeft MySQLi en PDO, en zo'n beetje iedereen die een beetje PHP programmeert heeft er zelf wel eens een geschreven. Zelfs jij. Het is dus niet de meest nuttige class om te schrijven, het is wel heel handig om het te leren, want er zijn zat voorbeelden.
Welke kant ga je op? Ga je één grote class maken die query() functie heeft, en een fetch() functie, waarmee je dus eigenlijk gewoon de mysql_* functies 1 op 1 in je class zet. Ga je hem uitbreiden met handige functies die queries genereren zoals select() en count()? Of ga je meer PDO's kant op waarbij prepare() en query() een PDOStatement object teruggeven waaruit je dan de results kan ophalen? Of ga je nog veel verder en ga je tabellen en velden en conditions en statements allemaal als classes modeleren zodat je je query volledig kan programmeren en kan genereren met PHP, waardoor je voor een simpele select-query plotseling 6 regels nodig hebt?
er bestaat hier al een functie voor, dus ik vind dit overbodig.
ILoran punt NL op 08/10/2010 23:19:27:
@Karl,
Waar slaat jouw reactie op?
Heel toevallig stond het zo in mijn schoolboek.....
Helaas wel!
"- GA ZELF DOOD NEER VALLEN!"
DOE NORMAAL!
Waar slaat jouw reactie op?
Heel toevallig stond het zo in mijn schoolboek.....
Helaas wel!
"- GA ZELF DOOD NEER VALLEN!"
DOE NORMAAL!
Inmiddels zou jij al twee dingen moeten weten. Namelijk dat schoolboeken het bijna nooit bij het juiste end hebben en dat exit / die doen omdat er een foutjes was ontzettend vies is.
Jij zegt nu in principe hetzelfde als ik tegen jou zeg. Denk eens na. Dat is toch helemaal niet de bedoeling?
Ook moet juist goed oppassen met schoolboeken, die bevatte vaak verkeerde / achterhaalde / slechte informatie.
Jelmer rrrr op 09/10/2010 00:24:33:
(...)
Welke kant ga je op? Ga je één grote class maken die query() functie heeft, en een fetch() functie, waarmee je dus eigenlijk gewoon de mysql_* functies 1 op 1 in je class zet. Ga je hem uitbreiden met handige functies die queries genereren zoals select() en count()? Of ga je meer PDO's kant op waarbij prepare() en query() een PDOStatement object teruggeven waaruit je dan de results kan ophalen? Of ga je nog veel verder en ga je tabellen en velden en conditions en statements allemaal als classes modeleren zodat je je query volledig kan programmeren en kan genereren met PHP, waardoor je voor een simpele select-query plotseling 6 regels nodig hebt?
Youri van Mill op 08/10/2010 14:39:33:
Ik ben nieuw in OOP.
Doe ik het zo goed, op deze manier?
Doe ik het zo goed, op deze manier?
(...)
Welke kant ga je op? Ga je één grote class maken die query() functie heeft, en een fetch() functie, waarmee je dus eigenlijk gewoon de mysql_* functies 1 op 1 in je class zet. Ga je hem uitbreiden met handige functies die queries genereren zoals select() en count()? Of ga je meer PDO's kant op waarbij prepare() en query() een PDOStatement object teruggeven waaruit je dan de results kan ophalen? Of ga je nog veel verder en ga je tabellen en velden en conditions en statements allemaal als classes modeleren zodat je je query volledig kan programmeren en kan genereren met PHP, waardoor je voor een simpele select-query plotseling 6 regels nodig hebt?
Of ga je nog verder en maak je er een ORM van zoals doctrine?
Internet Verslaafde op 09/10/2010 09:10:44:
Waarom zou je een class aanmaken om te connecten met MySQL,
er bestaat hier al een functie voor, dus ik vind dit overbodig.
er bestaat hier al een functie voor, dus ik vind dit overbodig.
Reasons for using classes.
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
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
<?php
/**
* Interface.php. Dit bestand bevat alle interfaces die bij de Database package horen.
* De Database package bevat alle klassen die rechtstreeks met de Database communiceren
* en gebruik maken van Database specifieke functies uit PHP.
* Dit bestand bevat alle interfaces die te maken hebben met de Database package.
* De interfaces dwingen af hoe een Database en een DatabaseResult eruit moet komen te zien.
*
* @package Database
* @throws DatabaseException
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
require_once dirname( __FILE__ ) . '/exception.php';
/**
* De Database interface. Deze interface wordt gebruikt om aan te geven hoe een Database eruit moet zien.
* De Database kan verbinding maken en er kunnen queries op uitgevoerd worden. Het resultaat van een query
* wordt verwerkt door het DatabaseResult. Alle methoden uit deze interface maken het mogelijk om op een
* generieke manier acties uit te voeren op de database.
*/
interface Database
{
/**
* Methode die verbinding met de database maakt. Gebruik makend van de meegegeven login gegevens
*
* @param String $host De host waar de database gehost staat
* @param String $username De gebruikersnaam om in te loggen op de database
* @param String $password Het wachtwoord om in te loggen op de database
* @param String $database De naam van de database waarmee verbinding gemaakt moet worden
* @return Void
*/
public function connect( $host, $username, $password, $database );
/**
* Methode om de opgegeven query uit te voeren op de database
*
* @param String $query De query die uitgevoerd moet worden op de database
* @throws DatabaseException Een opgetreden foutmelding wordt door de DatabaseException opgevangen.
* @return DatabaseResult Het resultaat van de query
*/
public function query( $query );
}
/**
* De DatabaseResult interface. Deze interface wordt gebruikt om een resultaat van een query op de Database
* te beschrijven.
*
* Op het moment dat een query uitgevoerd wordt, komt er een DatabaseResult terug. De DatabaseResult bevat
* het resultaat van de query en geeft de mogelijkheid om dit resultaat op diversen manieren op te vragen.
*/
interface DatabaseResult
{
/**
* Methode om een enkele regel uit het resultaat op te vragen in de vorm van een array met key => value
* paren. Elke key correspondeert met een geselecteerd veld uit de database.
*
* @return Array Een enkele regel uit het resultaat in vorm van een array met key => value paren
*/
public function fetch_assoc( );
/**
* Methode om het hele resultaat in één array op te vragen. De array is een lijst van alle geselecteerde
* regels opgevraagd met de fetch_assoc methode
*
* @return Array Een lijst met alle geselecteerde regels
*/
public function fetch_all( );
/**
* Methode om het aantal regels uit het resultaat op te vragen.
*
* @return Integer Het aantal regels waaruit het resultaat bestaat
*/
public function rows( );
}
?>
/**
* Interface.php. Dit bestand bevat alle interfaces die bij de Database package horen.
* De Database package bevat alle klassen die rechtstreeks met de Database communiceren
* en gebruik maken van Database specifieke functies uit PHP.
* Dit bestand bevat alle interfaces die te maken hebben met de Database package.
* De interfaces dwingen af hoe een Database en een DatabaseResult eruit moet komen te zien.
*
* @package Database
* @throws DatabaseException
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
require_once dirname( __FILE__ ) . '/exception.php';
/**
* De Database interface. Deze interface wordt gebruikt om aan te geven hoe een Database eruit moet zien.
* De Database kan verbinding maken en er kunnen queries op uitgevoerd worden. Het resultaat van een query
* wordt verwerkt door het DatabaseResult. Alle methoden uit deze interface maken het mogelijk om op een
* generieke manier acties uit te voeren op de database.
*/
interface Database
{
/**
* Methode die verbinding met de database maakt. Gebruik makend van de meegegeven login gegevens
*
* @param String $host De host waar de database gehost staat
* @param String $username De gebruikersnaam om in te loggen op de database
* @param String $password Het wachtwoord om in te loggen op de database
* @param String $database De naam van de database waarmee verbinding gemaakt moet worden
* @return Void
*/
public function connect( $host, $username, $password, $database );
/**
* Methode om de opgegeven query uit te voeren op de database
*
* @param String $query De query die uitgevoerd moet worden op de database
* @throws DatabaseException Een opgetreden foutmelding wordt door de DatabaseException opgevangen.
* @return DatabaseResult Het resultaat van de query
*/
public function query( $query );
}
/**
* De DatabaseResult interface. Deze interface wordt gebruikt om een resultaat van een query op de Database
* te beschrijven.
*
* Op het moment dat een query uitgevoerd wordt, komt er een DatabaseResult terug. De DatabaseResult bevat
* het resultaat van de query en geeft de mogelijkheid om dit resultaat op diversen manieren op te vragen.
*/
interface DatabaseResult
{
/**
* Methode om een enkele regel uit het resultaat op te vragen in de vorm van een array met key => value
* paren. Elke key correspondeert met een geselecteerd veld uit de database.
*
* @return Array Een enkele regel uit het resultaat in vorm van een array met key => value paren
*/
public function fetch_assoc( );
/**
* Methode om het hele resultaat in één array op te vragen. De array is een lijst van alle geselecteerde
* regels opgevraagd met de fetch_assoc methode
*
* @return Array Een lijst met alle geselecteerde regels
*/
public function fetch_all( );
/**
* Methode om het aantal regels uit het resultaat op te vragen.
*
* @return Integer Het aantal regels waaruit het resultaat bestaat
*/
public function rows( );
}
?>
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
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
<?php
/**
* mysql.database.php. Dit bestand bevat alle klassen die specifiek gericht zijn in het
* communiceren met een MySQL database.
*
* @package Database
* @throws DatabaseException
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
require_once dirname( __FILE__ ) . '/interface.php';
require_once dirname( __FILE__ ) . '/exception.php';
require_once dirname( __FILE__ ) . '/mysql.result.php';
/**
* De MySQL klasse. De MySQL is een implementatie van de Database interface specifiek gericht
* om te communiceren met een MySQL database
*/
class MySQL implements Database
{
/**
* In deze variabele wordt de database connectie opgeslagen
*
* @var MySQLObject
*/
private $connection;
/**
* Methode die verbinding met de database maakt. Gebruik makend van de meegegeven login gegevens
*
* @param String $host De host waar de database gehost staat
* @param String $username De gebruikersnaam om in te loggen op de database
* @param String $password Het wachtwoord om in te loggen op de database
* @param String $database De naam van de database waarmee verbinding gemaakt moet worden
* @return Void
*/
public function connect( $host, $username, $password, $database )
{
if( !$this->connection = mysql_connect( $host, $username, $password ) ) {
throw new DatabaseException( 'Kon geen verbinding met de database tot stand worden gebracht' );
}
if( !mysql_select_db( $database, $this->connection ) ) {
throw new DatabaseException( mysql_error( ) );
}
}
/**
* Methode om de opgegeven query uit te voeren op de database
*
* @param String $query De query die uitgevoerd moet worden op de database
* @throws DatabaseException Een opgetreden foutmelding wordt door de DatabaseException opgevangen.
* @return DatabaseResult Het resultaat van de query
*/
public function query( $query )
{
$result = mysql_query( $query, $this->connection );
if( !$result ) {
throw new DatabaseException( mysql_error( ) );
}
return new MySQLResult( $result );
}
}
?>
/**
* mysql.database.php. Dit bestand bevat alle klassen die specifiek gericht zijn in het
* communiceren met een MySQL database.
*
* @package Database
* @throws DatabaseException
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
require_once dirname( __FILE__ ) . '/interface.php';
require_once dirname( __FILE__ ) . '/exception.php';
require_once dirname( __FILE__ ) . '/mysql.result.php';
/**
* De MySQL klasse. De MySQL is een implementatie van de Database interface specifiek gericht
* om te communiceren met een MySQL database
*/
class MySQL implements Database
{
/**
* In deze variabele wordt de database connectie opgeslagen
*
* @var MySQLObject
*/
private $connection;
/**
* Methode die verbinding met de database maakt. Gebruik makend van de meegegeven login gegevens
*
* @param String $host De host waar de database gehost staat
* @param String $username De gebruikersnaam om in te loggen op de database
* @param String $password Het wachtwoord om in te loggen op de database
* @param String $database De naam van de database waarmee verbinding gemaakt moet worden
* @return Void
*/
public function connect( $host, $username, $password, $database )
{
if( !$this->connection = mysql_connect( $host, $username, $password ) ) {
throw new DatabaseException( 'Kon geen verbinding met de database tot stand worden gebracht' );
}
if( !mysql_select_db( $database, $this->connection ) ) {
throw new DatabaseException( mysql_error( ) );
}
}
/**
* Methode om de opgegeven query uit te voeren op de database
*
* @param String $query De query die uitgevoerd moet worden op de database
* @throws DatabaseException Een opgetreden foutmelding wordt door de DatabaseException opgevangen.
* @return DatabaseResult Het resultaat van de query
*/
public function query( $query )
{
$result = mysql_query( $query, $this->connection );
if( !$result ) {
throw new DatabaseException( mysql_error( ) );
}
return new MySQLResult( $result );
}
}
?>
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
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
<?php
/**
* mysql.result.php. Dit bestand bevat alle klassen die specifiek te maken hebben
* met het resultaatset van een MySQL database.
*
* @package Database
* @throws DatabaseException
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
/**
* De MySQLResult klasse is een implementatie van de DatabaseResult interface
* die specfieke gericht is op het communiceren met een MySQL database.
* De klasse vangt het resultaat op wat verkegen is van de MySQL database klasse.
*/
class MySQLResult implements DatabaseResult
{
/**
* In deze variabele wordt het resultaat opgeslagen
*
* @var MySQLResultObject
*/
private $result;
/**
* De constructor maakt een nieuwe MySQLResult gebruik makend van de result
* handler verkregen bij het uitvoeren van een query.
*
* @param Handler $result De result handler verkregen bij het uitvoeren van een query
* @return Void
*/
public function __construct( $result )
{
$this->result = $result;
}
/**
* Methode om een enkele regel uit het resultaat op te vragen in de vorm van een array met key => value
* paren. Elke key correspondeert met een geselecteerd veld uit de database.
*
* @return Array Een enkele regel uit het resultaat in vorm van een array met key => value paren
*/
public function fetch_assoc( )
{
return mysql_fetch_assoc( $this->result );
}
/**
* Methode om het hele resultaat in één array op te vragen. De array is een lijst van alle geselecteerde
* regels opgevraagd met de fetch_assoc methode
*
* @return Array Een lijst met alle geselecteerde regels
*/
public function fetch_all( )
{
$result = array( );
while( $row = $this->fetch_assoc( ) ) {
$result[] = $row;
}
return $result;
}
/**
* Methode om het aantal regels uit het resultaat op te vragen.
*
* @return Integer Het aantal regels waaruit het resultaat bestaat
*/
public function rows( )
{
return mysql_num_rows( $this->result );
}
}
?>
/**
* mysql.result.php. Dit bestand bevat alle klassen die specifiek te maken hebben
* met het resultaatset van een MySQL database.
*
* @package Database
* @throws DatabaseException
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
/**
* De MySQLResult klasse is een implementatie van de DatabaseResult interface
* die specfieke gericht is op het communiceren met een MySQL database.
* De klasse vangt het resultaat op wat verkegen is van de MySQL database klasse.
*/
class MySQLResult implements DatabaseResult
{
/**
* In deze variabele wordt het resultaat opgeslagen
*
* @var MySQLResultObject
*/
private $result;
/**
* De constructor maakt een nieuwe MySQLResult gebruik makend van de result
* handler verkregen bij het uitvoeren van een query.
*
* @param Handler $result De result handler verkregen bij het uitvoeren van een query
* @return Void
*/
public function __construct( $result )
{
$this->result = $result;
}
/**
* Methode om een enkele regel uit het resultaat op te vragen in de vorm van een array met key => value
* paren. Elke key correspondeert met een geselecteerd veld uit de database.
*
* @return Array Een enkele regel uit het resultaat in vorm van een array met key => value paren
*/
public function fetch_assoc( )
{
return mysql_fetch_assoc( $this->result );
}
/**
* Methode om het hele resultaat in één array op te vragen. De array is een lijst van alle geselecteerde
* regels opgevraagd met de fetch_assoc methode
*
* @return Array Een lijst met alle geselecteerde regels
*/
public function fetch_all( )
{
$result = array( );
while( $row = $this->fetch_assoc( ) ) {
$result[] = $row;
}
return $result;
}
/**
* Methode om het aantal regels uit het resultaat op te vragen.
*
* @return Integer Het aantal regels waaruit het resultaat bestaat
*/
public function rows( )
{
return mysql_num_rows( $this->result );
}
}
?>
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
/**
* Exception.php. Dit bestand bevat alle exception klassen de bij de Database package horen.
* De Database package bevat alle klassen die rechtstreeks met de Database communiceren
* en gebruik maken van Database specifieke functies uit PHP.
*
* @package Database
* @subpackage Exception
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
/**
* De DatabaseException klasse. De DatabaseException klasse is een extentie van de standaart
* Exception klasse en wordt gebruikt om fouten die optreden tijdens het gebruik van de database
* naar voren te brengen.
*
* De DatabaseException klasse is gemaakt om het mogelijk te maken om in een try catch blok
* het verschil te maken tussen een normale Exception en een DatabaseException
*/
class DatabaseException extends Exception { }
?>
/**
* Exception.php. Dit bestand bevat alle exception klassen de bij de Database package horen.
* De Database package bevat alle klassen die rechtstreeks met de Database communiceren
* en gebruik maken van Database specifieke functies uit PHP.
*
* @package Database
* @subpackage Exception
* @author Niels Kieviet <[email protected]>
* @version $Revision v.100$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
/**
* De DatabaseException klasse. De DatabaseException klasse is een extentie van de standaart
* Exception klasse en wordt gebruikt om fouten die optreden tijdens het gebruik van de database
* naar voren te brengen.
*
* De DatabaseException klasse is gemaakt om het mogelijk te maken om in een try catch blok
* het verschil te maken tussen een normale Exception en een DatabaseException
*/
class DatabaseException extends Exception { }
?>