Van MySQL naar MySQLi
Dit is een makkelijke voorbeeld:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$conn = mysql_connect("db-host","user","pass");
$db = mysql_select_db("db-name", $conn);
$result = mysql_query("SELECT * FROM `table`");
?>
$conn = mysql_connect("db-host","user","pass");
$db = mysql_select_db("db-name", $conn);
$result = mysql_query("SELECT * FROM `table`");
?>
Code (php)
1
2
3
4
2
3
4
<?php
$conn = mysqli_connect("db-host","user","pass","db-name")
$result = mysqli_query($conn, "SELECT * FROM `table`");
?>
$conn = mysqli_connect("db-host","user","pass","db-name")
$result = mysqli_query($conn, "SELECT * FROM `table`");
?>
Dit is de class (verbinding) wat ik wil aanpassen en mij vraag is hoe pas ik dit aan zonder te slopen?
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
<?php
class mysqlclass {
private $dbHost = '';
private $dbName = '';
private $dbUser = '';
private $dbPass = '';
private $htmlWriter;
//Helpers
private $dbConnection;
private $dbResult;
//Debug informatie;
private $dbError;
private $dbErrno;
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
$this->dbConnection = mysql_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
$this->dbError = mysql_error();
$this->dbErrno = mysql_errno();
throw new Exception($this->getErrors());
}
if (!mysql_select_db($this->dbName)){
$this->dbError = mysql_error();
$this->dbErrno = mysql_errno();
throw new Exception($this->getErrors());
}
}
//functie om een query uit te voeren.
function executeQuery($sql)
{
$this->htmlWriter->logDebugInfo("Executing: ".$sql."<br />\n");
$this->dbResult = mysql_query($sql);
if (!$this->dbResult){
$this->dbError = mysql_error();
$this->dbErrno = mysql_errno();
$msg = "<span style=\"color: red;\">Error while executing.<br />\n</span>\n";
$this->htmlWriter->logDebugInfo($msg);
throw new Exception($this->getErrors());
}
else{
$this->htmlWriter->logDebugInfo("Query executed.<br />\n");
}
}
//Functie om een resultaat in een array op te halen.
function getDataRow()
{
try{
$rows = mysql_fetch_array($this->dbResult);
if (count($rows) > 0){
mysql_free_result($this->dbResult);
}
return $rows;
}
catch (Exception $e){
throw new Exception($e->getMessage());
}
}
//Functie om het aantal opgehaalde rijen op te halen.
function getResultCount()
{
$counter = mysql_num_rows($this->dbResult);
$this->htmlWriter->logDebugInfo("Result count: ".$counter."<br />\n");
return $counter;
}
//Functie om het aantal aangepaste rijen op te halen.
function getAffectedRows()
{
$counter = mysql_affected_rows();
return $counter;
}
//Functie om een rij op te halen uit de database.
function getSingleRowAsObject()
{
$row = mysql_fetch_object($this->dbResult);
$this->htmlWriter->logDebugInfo("Geladen: ".$row->paginaID."<br />\n");
return $row;
}
//Functie om een aantal rijen op te halen uit de database.
function getRowsAsObjectArray()
{
$rows = array();
while ($row = mysql_fetch_object($this->dbResult)){
$rows[] = $row;
}
return $rows;
}
//Functie om een fout optehalen.
function getErrors(){
$retHtml = "<div class=\"errorDialog\">{$this->dbError}<br />\n{$this->dbErrno}</div>\n";
return $retHtml;
}
//Functie om de databse verbinding te sluiten.
function __destruct()
{
try{
$this->dbResult = null;
mysql_close($this->dbConnection);
}
catch(Exception $e){
throw new Exception($e->getMessage());
}
}
}
?>
class mysqlclass {
private $dbHost = '';
private $dbName = '';
private $dbUser = '';
private $dbPass = '';
private $htmlWriter;
//Helpers
private $dbConnection;
private $dbResult;
//Debug informatie;
private $dbError;
private $dbErrno;
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
$this->dbConnection = mysql_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
$this->dbError = mysql_error();
$this->dbErrno = mysql_errno();
throw new Exception($this->getErrors());
}
if (!mysql_select_db($this->dbName)){
$this->dbError = mysql_error();
$this->dbErrno = mysql_errno();
throw new Exception($this->getErrors());
}
}
//functie om een query uit te voeren.
function executeQuery($sql)
{
$this->htmlWriter->logDebugInfo("Executing: ".$sql."<br />\n");
$this->dbResult = mysql_query($sql);
if (!$this->dbResult){
$this->dbError = mysql_error();
$this->dbErrno = mysql_errno();
$msg = "<span style=\"color: red;\">Error while executing.<br />\n</span>\n";
$this->htmlWriter->logDebugInfo($msg);
throw new Exception($this->getErrors());
}
else{
$this->htmlWriter->logDebugInfo("Query executed.<br />\n");
}
}
//Functie om een resultaat in een array op te halen.
function getDataRow()
{
try{
$rows = mysql_fetch_array($this->dbResult);
if (count($rows) > 0){
mysql_free_result($this->dbResult);
}
return $rows;
}
catch (Exception $e){
throw new Exception($e->getMessage());
}
}
//Functie om het aantal opgehaalde rijen op te halen.
function getResultCount()
{
$counter = mysql_num_rows($this->dbResult);
$this->htmlWriter->logDebugInfo("Result count: ".$counter."<br />\n");
return $counter;
}
//Functie om het aantal aangepaste rijen op te halen.
function getAffectedRows()
{
$counter = mysql_affected_rows();
return $counter;
}
//Functie om een rij op te halen uit de database.
function getSingleRowAsObject()
{
$row = mysql_fetch_object($this->dbResult);
$this->htmlWriter->logDebugInfo("Geladen: ".$row->paginaID."<br />\n");
return $row;
}
//Functie om een aantal rijen op te halen uit de database.
function getRowsAsObjectArray()
{
$rows = array();
while ($row = mysql_fetch_object($this->dbResult)){
$rows[] = $row;
}
return $rows;
}
//Functie om een fout optehalen.
function getErrors(){
$retHtml = "<div class=\"errorDialog\">{$this->dbError}<br />\n{$this->dbErrno}</div>\n";
return $retHtml;
}
//Functie om de databse verbinding te sluiten.
function __destruct()
{
try{
$this->dbResult = null;
mysql_close($this->dbConnection);
}
catch(Exception $e){
throw new Exception($e->getMessage());
}
}
}
?>
Nu is de vraag wat heb ik allemaal gedaan?
- Eerst gezocht naar vergelijkbare class.
- Daarna PHP error geplaatst en dat geeft niet niks dan blanco scherm.
- PHP versie telkens verlaagd maar nog steeds blijft blanco scherm aangeven.
Gebruik 'm met goed resultaat.
https://github.com/bennettstone/simple-mysqli
Ik kan een hele lijst van dingen geven maar het meest in het oog springende is gelijk de constructor. Deze heeft geen parameters. Meteen als deze methode wordt aangeroepen gaat deze ook dingen instellen omtrent encoding?! Dit lijkt mij iets wat je regelt op applicatieniveau. Dat zou een database-class nooit op eigen houtje mogen regelen.
Ook lijkt er een voorliefde te bestaan voor het introduceren van constanten. Waarom? Waarom zouden database-credentials overal toegankelijk moeten zijn, en uberhaupt onthouden moeten worden? Deze data trek je ergens uit configuratie maar die kun je na het aanmaken van de connectie gewoon vergeten.
Daarnaast breekt dit ook met een ander OO-ontwerpprincipe: herbruikbaarheid. Wat nu als je toevallig een keer een tweede connectie nodig hebt? Dit is dan in het geheel niet mogelijk met deze klasse? :/
De character encoding is ook hard coded op "utf8", er zijn tegenwoordig veel meer andere, en uitgebreidere, UTF-8 spinoffs dan dat. Ook kun je geen poort instellen.
Kortom, er valt dus weinig te configureren aan connectie-credentials. Sure, voor de meeste basisinstallaties voldoet dit, maar als je deze code een keer wilt deployen op een server waar afwijkende standaarden worden gebruikt dan raak je mogelijk snel in de problemen.
Methoden als filter() en clean()... Wat zou je daar mee moeten? Input escaping? Ge-escapete data terugbreien naar een niet-ge-escapete variant? *brr*
Hulpfuncties als num_rows(), get_row() et cetera, waarom zitten die in een Database class? Deze horen thuis in een Database-result class.
Ik denk dat deze (monolythische) class niet erg flexibel is, te groot is omdat deze teveel dingen probeert te regelen, en deze je in sommige opzichten de verkeerde kant opstuurt qua aanpak m.b.t. escaping en security.
Gewijzigd op 07/07/2019 23:50:58 door Thomas van den Heuvel
Wat je in jouw geval moet doen is alle mysql_* functie vervangen door de mysqli_* varianten. Omdat de connectie al wordt opgeslagen in $this->dbConnection kun je in de meeste gevallen volstaan door die extra "i" aan de functienaam toe te voegen, en dan als 1e parameter "$this->dbConnection" invoegen (met wat uitzonderingen - read the docs, door bijvoorbeeld in je code dump hierboven op de linkjes te klikken, in een rood kader staat bovenaan steeds een link naar de mysqli_* variant).
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//dit is dus even anders
$this->dbError = mysqli_connect_error();
$this->dbErrno = mysqli_connect_errno();
throw new Exception($this->getErrors());
}
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
//enz
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//dit is dus even anders
$this->dbError = mysqli_connect_error();
$this->dbErrno = mysqli_connect_errno();
throw new Exception($this->getErrors());
}
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
//enz
Gewijzigd op 08/07/2019 09:30:35 door - Ariën -
Code (php)
1
&$
Code (php)
1
$
Door bovenstaande over te nemen heb ik nu dit melding:
Code (php)
1
Parse error: syntax error, unexpected '?>
Dit is nu de broncode:
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
89
90
91
92
93
94
95
96
97
98
99
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
89
90
91
92
93
94
95
96
97
98
99
<?php
class mysqlclass {
private $dbHost = 'localhost';
private $dbName = 'name';
private $dbUser = 'username';
private $dbPass = 'password';
private $htmlWriter;
//Helpers
private $dbConnection;
private $dbResult;
//Debug informatie;
private $dbError;
private $dbErrno;
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
//Functie om een resultaat in een array op te halen.
function getDataRow()
{
try{
$rows = mysqli_fetch_array($this->dbResult);
if (count($rows) > 0){
mysqli_free_result($this->dbResult);
}
return $rows;
}
catch (Exception $e){
throw new Exception($e->getMessage());
}
}
//Functie om het aantal opgehaalde rijen op te halen.
function getResultCount()
{
$counter = mysqli_num_rows($this->dbResult);
$this->htmlWriter->logDebugInfo("Result count: ".$counter."<br />\n");
return $counter;
}
//Functie om het aantal aangepaste rijen op te halen.
function getAffectedRows()
{
$counter = mysqli_affected_rows();
return $counter;
}
//Functie om een rij op te halen uit de database.
function getSingleRowAsObject()
{
$row = mysqli_fetch_object($this->dbResult);
$this->htmlWriter->logDebugInfo("Geladen: ".$row->paginaID."<br />\n");
return $row;
}
//Functie om een aantal rijen op te halen uit de database.
function getRowsAsObjectArray()
{
$rows = array();
while ($row = mysqli_fetch_object($this->dbResult)){
$rows[] = $row;
}
return $rows;
}
//Functie om een fout optehalen.
function getErrors(){
$retHtml = "<div class=\"errorDialog\">{$this->dbError}<br />\n{$this->dbErrno}</div>\n";
return $retHtml;
}
//Functie om de databse verbinding te sluiten.
function __destruct()
{
try{
$this->dbResult = null;
mysqli_close($this->dbConnection);
}
catch(Exception $e){
throw new Exception($e->getMessage());
}
}
}
?>
class mysqlclass {
private $dbHost = 'localhost';
private $dbName = 'name';
private $dbUser = 'username';
private $dbPass = 'password';
private $htmlWriter;
//Helpers
private $dbConnection;
private $dbResult;
//Debug informatie;
private $dbError;
private $dbErrno;
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
//Functie om een resultaat in een array op te halen.
function getDataRow()
{
try{
$rows = mysqli_fetch_array($this->dbResult);
if (count($rows) > 0){
mysqli_free_result($this->dbResult);
}
return $rows;
}
catch (Exception $e){
throw new Exception($e->getMessage());
}
}
//Functie om het aantal opgehaalde rijen op te halen.
function getResultCount()
{
$counter = mysqli_num_rows($this->dbResult);
$this->htmlWriter->logDebugInfo("Result count: ".$counter."<br />\n");
return $counter;
}
//Functie om het aantal aangepaste rijen op te halen.
function getAffectedRows()
{
$counter = mysqli_affected_rows();
return $counter;
}
//Functie om een rij op te halen uit de database.
function getSingleRowAsObject()
{
$row = mysqli_fetch_object($this->dbResult);
$this->htmlWriter->logDebugInfo("Geladen: ".$row->paginaID."<br />\n");
return $row;
}
//Functie om een aantal rijen op te halen uit de database.
function getRowsAsObjectArray()
{
$rows = array();
while ($row = mysqli_fetch_object($this->dbResult)){
$rows[] = $row;
}
return $rows;
}
//Functie om een fout optehalen.
function getErrors(){
$retHtml = "<div class=\"errorDialog\">{$this->dbError}<br />\n{$this->dbErrno}</div>\n";
return $retHtml;
}
//Functie om de databse verbinding te sluiten.
function __destruct()
{
try{
$this->dbResult = null;
mysqli_close($this->dbConnection);
}
catch(Exception $e){
throw new Exception($e->getMessage());
}
}
}
?>
Als ik bovenstaande voorbeeld overneem
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//dit is dus even anders
$this->dbError = mysqli_connect_error();
$this->dbErrno = mysqli_connect_errno();
throw new Exception($this->getErrors());
}
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//dit is dus even anders
$this->dbError = mysqli_connect_error();
$this->dbErrno = mysqli_connect_errno();
throw new Exception($this->getErrors());
}
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
Dus zo
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
<?php
class mysqlclass {
private $dbHost = 'localhost';
private $dbName = 'name';
private $dbUser = 'username';
private $dbPass = 'password';
private $htmlWriter;
//Helpers
private $dbConnection;
private $dbResult;
//Debug informatie;
private $dbError;
private $dbErrno;
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//dit is dus even anders
$this->dbError = mysqli_connect_error();
$this->dbErrno = mysqli_connect_errno();
throw new Exception($this->getErrors());
}
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
//Functie om een resultaat in een array op te halen.
function getDataRow()
{
try{
$rows = mysqli_fetch_array($this->dbResult);
if (count($rows) > 0){
mysqli_free_result($this->dbResult);
}
return $rows;
}
catch (Exception $e){
throw new Exception($e->getMessage());
}
}
//Functie om het aantal opgehaalde rijen op te halen.
function getResultCount()
{
$counter = mysqli_num_rows($this->dbResult);
$this->htmlWriter->logDebugInfo("Result count: ".$counter."<br />\n");
return $counter;
}
//Functie om het aantal aangepaste rijen op te halen.
function getAffectedRows()
{
$counter = mysqli_affected_rows();
return $counter;
}
//Functie om een rij op te halen uit de database.
function getSingleRowAsObject()
{
$row = mysqli_fetch_object($this->dbResult);
$this->htmlWriter->logDebugInfo("Geladen: ".$row->paginaID."<br />\n");
return $row;
}
//Functie om een aantal rijen op te halen uit de database.
function getRowsAsObjectArray()
{
$rows = array();
while ($row = mysqli_fetch_object($this->dbResult)){
$rows[] = $row;
}
return $rows;
}
//Functie om een fout optehalen.
function getErrors(){
$retHtml = "<div class=\"errorDialog\">{$this->dbError}<br />\n{$this->dbErrno}</div>\n";
return $retHtml;
}
//Functie om de databse verbinding te sluiten.
function __destruct()
{
try{
$this->dbResult = null;
mysqli_close($this->dbConnection);
}
catch(Exception $e){
throw new Exception($e->getMessage());
}
}
}
?>
class mysqlclass {
private $dbHost = 'localhost';
private $dbName = 'name';
private $dbUser = 'username';
private $dbPass = 'password';
private $htmlWriter;
//Helpers
private $dbConnection;
private $dbResult;
//Debug informatie;
private $dbError;
private $dbErrno;
//Constructor in deze klasse word de verbinding met de mysql db gemaakt.
function __construct($ht){
$this->htmlWriter = $ht;
//"i" invoegen
$this->dbConnection = mysqli_connect($this->dbHost, $this->dbUser, $this->dbPass);
if (!$this->dbConnection){
//dit is dus even anders
$this->dbError = mysqli_connect_error();
$this->dbErrno = mysqli_connect_errno();
throw new Exception($this->getErrors());
}
//vanaf hier "i" invoegen en "$this->dbConnection" als 1e param
if (!mysqli_select_db($this->dbName)){
$this->dbError = mysqli_error($this->dbConnection);
$this->dbErrno = mysqli_errno($this->dbConnection);
throw new Exception($this->getErrors());
}
}
//Functie om een resultaat in een array op te halen.
function getDataRow()
{
try{
$rows = mysqli_fetch_array($this->dbResult);
if (count($rows) > 0){
mysqli_free_result($this->dbResult);
}
return $rows;
}
catch (Exception $e){
throw new Exception($e->getMessage());
}
}
//Functie om het aantal opgehaalde rijen op te halen.
function getResultCount()
{
$counter = mysqli_num_rows($this->dbResult);
$this->htmlWriter->logDebugInfo("Result count: ".$counter."<br />\n");
return $counter;
}
//Functie om het aantal aangepaste rijen op te halen.
function getAffectedRows()
{
$counter = mysqli_affected_rows();
return $counter;
}
//Functie om een rij op te halen uit de database.
function getSingleRowAsObject()
{
$row = mysqli_fetch_object($this->dbResult);
$this->htmlWriter->logDebugInfo("Geladen: ".$row->paginaID."<br />\n");
return $row;
}
//Functie om een aantal rijen op te halen uit de database.
function getRowsAsObjectArray()
{
$rows = array();
while ($row = mysqli_fetch_object($this->dbResult)){
$rows[] = $row;
}
return $rows;
}
//Functie om een fout optehalen.
function getErrors(){
$retHtml = "<div class=\"errorDialog\">{$this->dbError}<br />\n{$this->dbErrno}</div>\n";
return $retHtml;
}
//Functie om de databse verbinding te sluiten.
function __destruct()
{
try{
$this->dbResult = null;
mysqli_close($this->dbConnection);
}
catch(Exception $e){
throw new Exception($e->getMessage());
}
}
}
?>
dan krijg ik dit te zien
Code (php)
1
2
3
2
3
Warning: mysqli_select_db() expects exactly 2 parameters, 1 given in mysql.class.php on line 30
Fatal error: Uncaught Exception: <div class="errorDialog"><br /> 0</div> in mysql.class.php:33 Stack trace: #0 index.php(14): mysqlclass->__construct(Object(htmlWriter)) #1 {main} thrown in mysql.class.php on line 33
Fatal error: Uncaught Exception: <div class="errorDialog"><br /> 0</div> in mysql.class.php:33 Stack trace: #0 index.php(14): mysqlclass->__construct(Object(htmlWriter)) #1 {main} thrown in mysql.class.php on line 33
Gewijzigd op 14/07/2019 17:29:37 door Kim Kim
Leuk dat je alles in try-catch blokken zet, maar lang niet alles genereert automatisch exceptions als er dingen misgaan.
fetch_array() retourneert een enkel record, dus ik zie niet helemaal waarom je vervolgens het hele resultaat (met mogelijk resterende nog op te halen rijen) wegkiepert? Daarnaast retourneert dit zowel een genummerd alsook een associatieve indexering. Kies een van beide. Los daarvan, dit betreft resultsets, en geen database(connectie)s, dus dit zou je -zoals al eerder aangehaald- voor de goede orde in een aparte class moeten regelen.
Gewoon naar de prullenbak slepen dit geval.
Een gemiddelde site heeft daar al voldoende aan, en als je functionaliteit mist (queries tellen bijv.), dan kan je die altijd bouwen door de MySQLi-class te extenden.
Eventueel kan je een wrapper-class bouwen die alle databasefuncties en objecten verpakt, zodat je later makkelijk een overstap of upgrade kan maken. Maar zelf betwijfel ik of het waardevol is, gezien je de bouw extra tijd kost dan het oplevert, en een beetje editor voldoende tools hebben om dit aan te passen.
Maar voor wie zich er prettig bij voelt: Ga je gang.
Gewijzigd op 14/07/2019 22:34:12 door - Ariën -
- Ariën - op 14/07/2019 22:33:49:
Eventueel kan je een wrapper-class bouwen die alle databasefuncties en objecten verpakt, zodat je later makkelijk een overstap of upgrade kan maken. Maar zelf betwijfel ik of het waardevol is, gezien je de bouw extra tijd kost dan het oplevert, en een beetje editor voldoende tools hebben om dit aan te passen.
Als de wrapper geen toegevoegde waarde heeft dan zou ik zeggen dat het bovenstaande opgaat. Maar als deze wel toegevoegde waarde heeft dan verdient het zijn tijd ook weer terug op den duur. Dit hoeft ook helemaal niet uitgebreid of ingewikkeld te zijn.
Indien de wrapper niets toevoegt kun je net zo goed de standaard functionaliteit gebruiken, maar...
Daarnaast lijk je nog een ander aspect te vergeten. Een wrapper is precies dat: een andere, en hopelijk, generiekere, manier om hetzelfde te doen. Een wrapper centraliseert code die specifieke taken vervult. Nu de support voor mysql weg begint te vallen doordat men de overstap naar PHP 7 maakt is iedereen hals over kop alles aan het omzetten van mysql naar mysqli.
Als je gewoon alles zou searchen en replacen bega je eigenlijk een grote fout. Je bent dan namelijk de hard coding van database oplossing A aan het vervangen door een haast exact gelijkende hard coding van database oplossing B. Had je voor je mysql connectie ook een wrapper gebruikt, dan hoefde je in het gunstigste geval enkel de implementatie van de wrapper aan te passen - je hoeft dan slechts een paar bestanden te doorlopen, in plaats van je complete codebase. Uiteraard moet je dan alles nog wel even testen. En uiteraard is een wrapper geen volledige ontkoppeling van je database-oplossing, maar het voorkomt wel hard coding.
En wie zegt dat mysql -> mysqli de laatste omzetting was in mysql-land? Een ezel stoot zich in het algemeen...
Gewijzigd op 15/07/2019 15:32:26 door Thomas van den Heuvel
Het ligt echt aan hoe groot je codebase is. Als je een framework gebruikt zoals Symfony, CI, Zend, Laravel of wat dan ook, dan hoef je enkel een configuratieding aan te passen. Mits je dit het framework natuurlijk op-to-date houdt.
In mijn ogen voldoet voor een standaard-site de standaard MySQLi-class die je kan extenden al prima.
Quote:
Maar op het moment dat er een nieuwe PHP-versie uitkomt met nodige mysqli-functie-wijzigingen, dan is er vaak nog meer nodig dan enkel wat mysqli-functies aanpassen
Niet als je in je wrapper definieert wat voor taken je wilt uitvoeren op je database. Deze taken zijn vrij universeel. Als je wrapper goed in elkaar zit is het werk minimaal.
Quote:
In mijn ogen is een 'search & replace' een goede oplossing.
Mja als je frequentie en omvang buiten beschouwing laat. Wat als al je projecten op deze manier in elkaar zitten? Good luck.
Quote:
Daarom doe je je dit liever niet volledig geautomatiseerd.
Dat betekent handwerk. Dan zou ik, hands down, elke keer gaan voor het vervangen van een wrapper(implementatie).
Quote:
Het ligt echt aan hoe groot je codebase is. Als je een framework gebruikt zoals Symfony, CI, Zend, Laravel of wat dan ook, dan hoef je enkel een configuratieding aan te passen. Mits je dit het framework natuurlijk op-to-date houdt.
Dat mag ik ook hopen. Een framework biedt de meeste bouwstenen kant en klaar aan. Dan ga ik er vanuit dat deze zo in elkaar zitten dat de specificatie van functionaliteit niet ineens verandert op het moment dat een onderliggende technologie verandert.
Quote:
In mijn ogen voldoet voor een standaard-site de standaard MySQLi-class die je kan extenden al prima.
Als je alleen maar bakstenen programmeert waar je vervolgens nooit meer naar omkijkt is dit inderdaad prima.
Maar hard coding is nooit een goed ontwerpprincipe. Dit zou je dus moeten vermijden.