Informatie over mysql_error()
Nu wil ik weten: hoe weet mysql_error() welke actie dat was?
Ik wil die ook weten.
Het liefst wil ik met een functie de laatste uitgevoerde query weten!
Helaas kan ik dat niet vinden op internet.
Niet met PHP, niet met SQL zelf (ook niet in de information_schema-database).
Maar blijkbaar kan mysql_error() dat wel.
Tevens een vraag: bij mysql_query() hoeft je geen link-indentifier aan te geven.
Hoe vraag ik op welke link-indentifier actief is?
Zodat ik mysql_stat() kan gebruiken, ZONDER zelf die link-indentifier op te geven.
Dit omdat ik bezig ben met een wat gevorderde mysql_count_rows() (ik noem hem anders, maar dat doet het in theorie).
Gesponsorde koppelingen:
Zet de queries die je uitvoert eerst in een variabele en echo deze als er een fout optreedt:
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
$sql = "SELECT * FROM tabel";
if(!$result = mysql_query($sql))
{
trigger_error(mysql_error() . ' in query: ' . $sql);
}
else
{
// verder met script
}
?>
$sql = "SELECT * FROM tabel";
if(!$result = mysql_query($sql))
{
trigger_error(mysql_error() . ' in query: ' . $sql);
}
else
{
// verder met script
}
?>
De functie mysql_query() pakt automatisch de verbinding die het laatste opgezet is. Wil jij een verbinding gebruiken die je eerder opgezet hebt, dan zul je dus de link-identifier wel mee moeten geven:
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
<?php
$conn1 = mysql_connect(...); // Server 1
$conn2 = mysql_connect(...); // Server 2
mysql_query($sql); // Query op server 2
mysql_query($sql, $conn1); Query op server 1
?>
$conn1 = mysql_connect(...); // Server 1
$conn2 = mysql_connect(...); // Server 2
mysql_query($sql); // Query op server 2
mysql_query($sql, $conn1); Query op server 1
?>
Blanche schreef op 21.09.2008 10:26:
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
$sql = "SELECT * FROM tabel";
if(!$result = mysql_query($sql))
{
trigger_error(mysql_error() . ' in query: ' . $sql);
}
else
{
// verder met script
}
?>
$sql = "SELECT * FROM tabel";
if(!$result = mysql_query($sql))
{
trigger_error(mysql_error() . ' in query: ' . $sql);
}
else
{
// verder met script
}
?>
Wat jij doet kan ook, maar is weer zo ongelofelijk veel code!
Ik wil ongeveer dit maken:
Dus niets in variabelen willen mikken etc.
Gewoon 1x een functie uitvoeren die ALLES doet.
Ik wil dus ook niet een variabele of link-identifier opgeven.
Dat moet de functie zelf uitvogelen.
Immers, mysql_query() kan dat ook (betreffende de link-identifier). Dus moet ik dat ook kunnen.
De vraag is: hoe doe ik dat?
Blanche schreef op 21.09.2008 10:26:
De functie mysql_query() pakt automatisch de verbinding die het laatste opgezet is. Wil jij een verbinding gebruiken die je eerder opgezet hebt, dan zul je dus de link-identifier wel mee moeten geven:
Waarom? mysql_query() heeft dat ook niet nodig, dus mijn functie moet dat ook niet nodig kunnen hebben ;).
Eddy Erkelens schreef op 23.09.2008 18:17:
En sinds wanneer is het verboden om goede en duidelijke code te schrijven? Dat kost meestal minder tijd dat de brakke ellende die hier dagelijks wordt getoond...maar is weer zo ongelofelijk veel code!
Ga met OOP aan de slag en ga met try-catch alle mogelijke en onmogelijke foutmeldingen afvangen, dan vang je hem daar op waar je er wat mee kunt doen.
En ga niet denken dat alles compact moet zijn, dat is vaak vele dikke ellende op het moment dat er iets fout gaat.
Overigens heb je altijd een link identifier nodig, al kan het zijn dat er een default link identifier aanwezig is. Zonder verbinding is er geen verbinding... Duhhh!
En als je fouten-opvang goed is (en dat wil ik bereiken met die functie), dan hoef je niet met IF's te werken.
Want or function() is immers aan een IF-gelijk!
Ik ga niet OOPen hierzo ;).
link-identifier heb je wel nodig, maar wil ik niet handmatig opgeven.
Voordat je een mysql_query() (of mysqli_...) uitvoerd moet je al verbinding hebben gemaakt.
En aangezien de functie altijd later komt, is dat geen probleem.
En zo wel: dan moet de functie dat kunnen zien ;).
Dus de vraag blijft staan: "Hoe pak ik automatisch de (laatst actieve) link-identifier? ", zonder handmatig op te geven?
En wat is het probleem met een if? Die dingen zijn zó eenvoudig, nog veel eenvoudiger kan het gewoon niet. En ja, alles wat fout kan gaan, zal ook fout gaan. Anticipeer daar dan ook op, dat maakt het programmeren een heel stuk eenvoudiger.
Overbodige code is vooral compacte code waar je niets/te weinig in controleert, die kan namelijk zo richting schroothoop. En dan kun je weer overnieuw beginnen...
or function() lijkt leuk en aardig, maar je kunt niet bij iedere fout op dezelfde manier actie ondernemen. Een mislukte INSERT-query heeft hele andere gevolgen dan een mislukte SELECT. Bij een UPDATE of DELETE spelen er weer hele andere zaken.
Tip: Kijk toch eens naar try-catch, dat maakt de boel echt een stuk eenvoudiger.
pgFrank schreef op 23.09.2008 19:36:
En hoe denk jij zonder een if te controleren of je query is gelukt?
Zo:
pgFrank schreef op 23.09.2008 19:36:
En wat is het probleem met een if? Die dingen zijn zó eenvoudig, nog veel eenvoudiger kan het gewoon niet. En ja, alles wat fout kan gaan, zal ook fout gaan. Anticipeer daar dan ook op, dat maakt het programmeren een heel stuk eenvoudiger.
Dat is zo, daarom wil ik hem ook opvangen.
Maar dan wel met weinig code, en het liefst universeel!
Dus 1 functie voor alle queries en niet bij iedere query 10 regels IF-code extra (om daar dan uiteindlijk een error-class of exception-class/functie aan te roepen).
pgFrank schreef op 23.09.2008 19:36:
Overbodige code is vooral compacte code waar je niets/te weinig in controleert, die kan namelijk zo richting schroothoop. En dan kun je weer overnieuw beginnen...
Het is vooral om het wat universeler te krijgen.
En ja: je kan classes gaan gebruiken (zoals PDO), maar dat wil ik niet.
Het is geen overbodige code. Als goed is (!), dus met juiste voorbereiding zal de functie nooit/niet aangeroepen worden. Alleen bij fouten in de SQL.
En goede (compacte) code, die universeel is, hoeft niet weer gecontroleerd te worden.
Mijn functie zorgt er niet voor dat de query gaat lukken (input beveiligen), maar vangt de fouten op en geeft ze netjes weer. Zonder gezeur en halve foutmeldingen.
Mooiste zou zijn (dat is mijn doel) om onderaan de pagina eenmalig de functie aan te roepen. Dat die dan ook nog eens ALLE queries van die pagina weergeeft (uitgeschreven, als zijnde string) en of die lukt of niet.
Dat zal dan wel iets anders worden (dwz: geen fouten-opvang maar als ontwerp-hulpstuk), maar zal dezelfde functionaliteiten (php-functies) gebruiken.
pgFrank schreef op 23.09.2008 19:36:
or function() lijkt leuk en aardig, maar je kunt niet bij iedere fout op dezelfde manier actie ondernemen. Een mislukte INSERT-query heeft hele andere gevolgen dan een mislukte SELECT. Bij een UPDATE of DELETE spelen er weer hele andere zaken.
Dat is waar. Daarom wil ik dus ook weten welke query er als laatste uitgevoerd is.
Om dat te weten te komen, moet ik eerst de de link-identifier hebben.
Maar hoe krijg ik die?
pgFrank schreef op 23.09.2008 19:36:
Tip: Kijk toch eens naar try-catch, dat maakt de boel echt een stuk eenvoudiger.
Eenvoudig, net als de IF-constructors.
Maar ik wil gewoon een goede debug-functie latne uitvoeren bij fouten ;).
En die de fouten dus goed opvangt.
En wat als er een resultset komt zonder resultaten? Hoe ga jij dan op het scherm zetten: "geen resultaten gevonden". Toch maar weer een if-je gebruiken?
Queries gaan overigens niet alleen fout wanneer de SQL fout is, ook wanneer de input niet goed is of de database (even) niet bereikbaar is. Die fouten zul je dus ook moeten opvangen. En dat gebeurt echt niet alleen tijdens bouwen en testen, ook (en vooral) wanneer de applicatie live is.
Foutafhandeling bouw je niet alleen om het bouwen, testen en debuggen eenvoudiger te maken, maar ook om een gebruiker altijd de juiste meldingen te kunnen geven. En de beheerder/administrator van de juiste data te voorzien om het daadwerkelijke probleem aan te pakken.
De aanname "dat als het goed is de functie nooit wordt aangeroepen" is zo'n beetje de grootste fout die je kunt maken! Fouten maken is menselijk, dus maak jij ook fouten in je code. Daarnaast gaat altijd alles fout wat ook maar fout kan gaan, dus je hebt 100% zekerheid dat de functie met enige regelmaat wordt aangeroepen. Mits je één algemene functie kunt gebruiken om fouten af te handelen...
Lijkt me sterk, een ROLLBACK uitvoeren wanneer een SELECT mislukt, zal weinig uithalen. Een INSERT uitvoeren terwijl de SELECT die je nodig hebt is mislukt, heeft evenmin veel zin, de INSERT kun je dan wel afkappen. En dat zonder een vieze die() te gebruiken... Dat gaat je dus allemaal niet lukken met één functie, dit klinkt echt als vele if-else-jes of een fraaie try-catch-constructie.
MySQL is trouwens vrij karig met foutmeldingen, zeker zonder fatsoenlijke configuratie, en het achterhalen van de échte foutmelding is regelmatig een vrij lastige klus.
Ga nu gewoon aan de slag met try-catch, dat is hier voor gemaakt.
Code (php)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
<?php
if($result = mysql_query($sql)){
//goedgegaan, ga door (evt nog tellen van het aantal gevonden records!)
}
else{
//niet goedgegaan, roep je eigen functie aan
// BIJNA HETZELFDE ALS TRY/ CATCH
}
?>
if($result = mysql_query($sql)){
//goedgegaan, ga door (evt nog tellen van het aantal gevonden records!)
}
else{
//niet goedgegaan, roep je eigen functie aan
// BIJNA HETZELFDE ALS TRY/ CATCH
}
?>
