ASP bijlage

Mijn eerste ASP pagina: Hallo wereld!
Een ASP pagina bestaat uit script en eventueel HTML. Het script staat tussen
<% en %> en kan tussen de HTML in staan.

Om pagina's dynamisch te maken, moet je met ASP tekst naar de browser kunnen sturen. Dit kun je doen met het Response.Write statement. De waarde die we hieraan meegeven wordt naar de browser gestuurd. We kunnen dit het beste laten zien met een voorbeeld:

helloworld1.asp
<HTML>
<BODY>
<%
'Schrijf naar de browser
Response.Write "Hallo wereld!"
%>
</BODY>
</HTML>

Voor de regel die daadwerkelijk wat doet, staat een regel met een '-teken ervoor. Dit is commentaar, waardoor je beter ziet wat er gebeurt. Het is, vooral met grotere stukken code, verstandig om commentaar in te voegen. Zoals je ziet staat de code midden tussen de HTML. Dit hoeft niet op één plek te zijn, dat kan ook op meerdere plaatsen. Bijvoorbeeld zo:

helloworld2.asp
<HTML>
<HEAD>
<TITLE>
<%
Response.Write "Voorbeeld: Hallo wereld!"
%>
</TITLE>
</HEAD>
<BODY>
<%
Response.Write "Hallo wereld!"
%>
</BODY>
</HTML>

In het bovenstaande script schrijven we niet alleen wat in het browser-scherm, maar ook in de titelbalk.

Het is niet verstandig om te veel HTML en ASP door elkaar te zetten. ASP moet dan vaak een zogenaamde context switch maken en dat kost tijd.

Response.Write
Response.Write bestaat eigenlijk uit twee delen. Het gedeelte voor de punt is het Response object, dat gebruikt wordt voor interactie met de gebruiker. Het tweede gedeelte is een methode van het Response object. In dit geval is dat de Write methode, waarmee tekst naar de browser gestuurd wordt. Andere methoden worden in andere lessen besproken.

Werken met variabelen

Variabelen worden gebruikt om een waarde in op te slaan. Deze waarde kan tijdens het uitvoeren van de code veranderen, maar we kunnen de waarde telkens gebruiken door de naam op te geven. In de meeste programmeertalen heeft een variabele een datatype. In ASP is dit echter niet zo, alle variabelen zijn van het type Variant (VBScript). Een variabele heeft wel een impliciet subtype. Dit kan nog wel eens tot rare dingen leiden doordat bijvoorbeeld een nummer met een tekst die een nummer weergeeft wordt vergeleken, terwijl deze voor het programma niet gelijk zijn.

Het onderstaande voorbeeld illustreert het gebruik van variabelen. Er wordt een variabele gemaakt die vervolgens naar de browser geschreven wordt:

vars1.asp
<HTML>
<BODY>
<%
MijnVar = "Hallo wereld!"

Response.Write MijnVar
%>
</BODY>
</HTML>

In het bovenstaande voorbeeld wordt de variabele zomaar gebruikt. Hoewel dit zonder meer kan heeft dit een ernstig nadeel. Als je een typfout zou maken, dan is het resultaat onjuist. Stel je voor dat we Response.Write MijnVa hadden geschreven. Dan zou ASP dat als een nieuwe variabele beschouwen en zou er niets in de browser verschijnen. Het is daarom handig om het verplicht te maken variabelen eerst te declareren. Dit doe je door als eerste regel in het script het Option Explicit statement te plaatsen. Daarna moet elke variabele eerst benoemd worden met het Dim statement.

vars2.asp
<%Option Explicit%>
<HTML>
<BODY>
<%
Dim MijnVar

MijnVar = "Hallo wereld!<br>"

Response.Write MijnVar
MijnVar = " Dit script gebruikt Option Explicit"

Response.Write MijnVar
%>
</BODY>
</HTML>

Als we in de bovenstaande code dezelfde fout zouden maken, dan zou ASP een foutmelding geven en ons melden dat de variabele niet bestaat.

Werken met array's

Een array is een variabele waarin meerdere waarden tegelijk opgeslagen kunnen worden. Iedere waarde heeft een andere plek in de array die bepaald wordt met een index. Deze waarden kunnen net als bij een normale variabele gewijzigd worden als de code wordt uitgevoerd.

Een array wordt op dezelfde manier gedeclareerd als een gewone variabele, maar erachter wordt tussen haakjes weergegeven hoeveel waarden er in moeten passen.

array1.asp
<%
Option Explicit

Dim MijnArray(3)

MijnArray(0) = "Piet"
MijnArray(1) = "Jan"
MijnArray(2) = "Klaas"
%>
<HTML>
<BODY>
<%
Response.Write "Namen:<br>"
Response.Write MijnArray(0) & " <br>"
Response.Write MijnArray(1) & " <br>"
Response.Write MijnArray(2) & " <br>"
%>
</BODY>
</HTML>

Werken met keuze statements

Met keuze statements kunnen we een stuk code al dan niet uitvoeren. Als er aan een bepaalde voorwaarde voldaan wordt, wordt de code uitgevoerd, anders niet. Er zijn twee soorten keuze statements, If ... Then en Select Case. Beiden worden hieronder besproken.

If ... Then

Het If ... Then statement is betrekkelijk eenvoudig, en kan het beste uitgelegd worden met een voorbeeld:

ifthen1.asp
<%
Option Explicit

Dim blDoen

blDoen = True
%>
<HTML>
<BODY>
<%
If blDoen = True Then
Response.Write "Deze code wordt uitgevoerd"
Else
Response.Write "Deze code wordt NIET uitgevoerd"
End If
%>
</BODY>
</HTML>

De code hierboven kijkt of de variabele blDoen waar is en voert vervolgens de code meteen na deze test uit (want het klopt). Was dit niet het geval geweest, dan was de code na Else uitgevoerd. De constructie wordt afgesloten met End If.

Noot: In de bovenstaande code is de naam van de variabele voorafgegaan door bl. Dit is zodat je onthoudt dat we met een variabele van het sub-type Boolean werken. Een Boolean kan twee waarden hebben, True (waar) of False (niet waar).

Zouden we meer voorwaarden hebben, dan kunnen we deze aaneen schakelen met And (en) of Or (of). Verder kunnen we ook meerdere ElseIf ... Then statements toevoegen om meerdere keuzes te hebben. Het voorbeeld hieronder laat beide zien.

ifthen2.asp
<%
Option Explicit

Dim lngGetal
Dim blDoen

blDoen = True
lngGetal = 2
%>
<HTML>
<BODY>
<%
If blDoen = True And lngGetal = 1 Then
Response.Write "Deze code wordt NIET uitgevoerd"
ElseIf blDoen = True And lngGetal = 2 Then
Response.Write "Deze code wordt uitgevoerd"
ElseIf blDoen = True Or lngGetal = 3 Then
Response.Write "en deze code wordt ook NIET uitgevoerd"
Else
Response.Write "Deze code wordt NIET uitgevoerd"
End If
%>
</BODY>
</HTML>

Select Case

Bij het If ... Then statement zagen we dat we meerdere keuzes konden geven door ElseIf ... Then statements te gebruiken. Met het Select Case statement kunnen we dezelfde constructie maken, alleen dan makkelijker. Hierbij wordt eenmalig een expressie (een variabele of een serie statements die tot een variabele evalueren) gegeven en het resultaat daarvan wordt telkens vergeleken met de gegeven Case. Ook dit is makkelijk uitgelegd met een voorbeeld:

select1.asp
<%
Option Explicit

Dim lngGetal

lngGetal = 2
%>
<HTML>
<BODY>
<%
Select Case lngGetal
Case 1
Response.Write "Deze code wordt NIET uitgevoerd"
Case 2
Response.Write "Deze code wordt uitgevoerd"
Case 3
Response.Write "Deze code wordt NIET uitgevoerd"
Case Else
Response.Write "Deze code wordt NIET uitgevoerd"
End Select
%>
</BODY>
</HTML>

Noot: In de bovenstaande code is de naam van de variabele voorafgegaan door lng. Dit is zodat je onthoudt dat we met een variabele van het sub-type Long werken. Een Long is een getal-type dat waarden kan hebben tussen 2.147.483.648 en -2.147.483.647.

Opdrachten meerdere keren uitvoeren

Het kan in veel gevallen handig zijn om een stuk code meerdere keren uit te voeren. Bijvoorbeeld als je de waarden uit een array weer wilt geven. Je kunt daarvoor telkens dezelfde code gebruiken, als de index maar verandert. Dit is vooral handig als je van te voren niet weet hoeveel waarden een array bevat.

Je kunt opdrachten meerdere keren uitvoeren met behulp van loops. Er zijn twee soorten loops, een die een bepaald aantal keer uitgevoerd wordt en een die uitgevoerd wordt totdat er aan een bepaalde voorwaarde is voldaan (of zolang er juist niet aan een bepaalde voorwaarde is voldaan). De eerste noemen we een For ... Next loop, de andere een Do ... Loop loop. Hieronder worden ze beiden besproken.

For ... Next

Een For ... Next loop werkt op basis van een teller die we eerst declareren. Er wordt vervolgens aangegeven waar de teller moet beginnen en waar die moet eindigen. Deze teller wordt elke keer als de opdrachten uitgevoerd zijn met één verhoogd, totdat de hoogste waarde is bereikt. Eventueel kan de teller ook met meer tegelijk verhoogd worden. Het voorbeeld hieronder is heel eenvoudig. De index wordt bij iedere stap naar de browser geschreven (met een harde return).

fornext1.asp
<%
Option Explicit

Dim i

%>
<HTML>
<BODY>
<%
For i = 1 To 20
Response.Write i & "<br>"
Next
%>
</BODY>
</HTML>

Array's lenen zich erg goed voor dergelijke loops. Je kunt dit zien in het onderstaande voorbeeld. Hierin gebruiken we de Split functie om een string met waarden gescheiden door komma's om te vormen tot een array. Vervolgens gebruiken we de UBound functie om te kijken hoeveel waarden er in de array zitten.

fornext2.asp
<%
Option Explicit

Dim i
Dim strWaarden
Dim aWaarden
Dim lngAantal

strWaarden = "Jan,Piet,Klaas,Kees"

'Splits string en zet in array
aWaarden = Split(strWaarden, ",")

'Kijk hoeveel waarden er in de array zitten
lngAantal = UBound(aWaarden)
%>
<HTML>
<BODY>
<%
For i = 0 To lngAantal
Response.Write aWaarden(i) & "<br>"
Next
%>
</BODY>
</HTML>

Do ... Loop

Do ... Loop heeft meer mogelijkheden dan For ... Next, maar je moet ook meer zelf doen. Je moet zelf bepalen welke voorwaarden er moeten zijn om de code (nogmaals) uit te voeren. Als je een teller gebruikt moet je die ook zelf ophogen. Als je dit vergeet, blijft de loop oneindig doorlopen. We geven twee voorbeelden:

doloop1.asp
<%
Option Explicit

Dim i
%>
<HTML>
<BODY>
<%
'Initialiseer waarde
i = 1

Do While i < 21
Response.Write i & "<br>"
i = i + 1
Loop
%>
</BODY>
</HTML>

doloop2.asp
<%
Option Explicit

Dim i
%>
<HTML>
<BODY>
<%
'Initialiseer waarde
i = 1

Do
Response.Write i & "<br>"
i = i + 1
Loop Until i = 21
%>
</BODY>
</HTML>

In het tweede voorbeeld weet je dat de opdrachten minimaal één keer worden uitgevoerd. In het voorbeeld daarvoor is dat niet zo. Verder zijn While en Until uitwisselbaar. Het hangt af van de situatie welke handiger is om te gebruiken.

Werken met formulieren

In dynamische sites komt het veel voor dat de gebruiker via een HTML-formulier gegevens naar de server stuurt. Met ASP kunnen we die gegevens gebruiken om bijvoorbeeld op te slaan in een database, te versturen via een email of juist andere gegevens op te zoeken.

De gegevens in een formulier kunnen op twee manieren naar de server gestuurd worden, met de POST of met de GET methode. Met POST worden de gegevens naar de server gestuurd als onderdeel van de HTTP headers, met GET als onderdeel van de URL. In het laatste geval staan de gegevens achter een ? dat achter de bestandsnaam staat:
http://www.voorbeeld.nl/voorbeeld.asp?naam=Jan%20Smit&land=Nederland

De verschillende waarden worden gescheiden door & tekens, verder worden bijvoorbeeld spaties gecodeerd zodat er geen onbruikbare URL ontstaat. GET heeft als nadeel dat de gegevens deel uit maken van de URL, wat vooral onhandig is als het om bijvoorbeeld een password gaat. Verder is de lengte van een URL beperkt, voor de meeste browsers tot ongeveer 1.000 karakters.

Welke manier je ook gebruikt, de waarden in het formulier zijn ALTIJD van het subtype String. Dit betekent dat als je een getal verstuurt deze toch nog eerst geconverteerd moet worden naar een getal subtype zoals Integer, Long, Single of Double. Dit kan respectievelijk met de functies CInt(), CLng(), CSng() en CDbl().

Gegevens gebruiken met de POST methode
Wanneer de POST methode is gebruikt, kunnen we waardes uitlezen uit de Form Collectie van het Request object met de opdracht Request.Form("NaamVanWaarde"). Hieronder zie je een voorbeeld van het HTML formulier en vervolgens de code om er wat mee te doen.

form1.asp
<HTML>
<BODY>
<form method="POST" action="form1post.asp">
<table>
<tr>
<td>
Naam
</td>
<td>
<input type="text" name="naam">
</td>
</tr>
<tr>
<td>
Land
</td>
<td>
<input type="text" name="land">
</td>
</tr>
</table>
<input type="submit" value="Verstuur">
<form>
</BODY>
</HTML>

form1post.asp
<%
Option Explicit
%>
<HTML>
<BODY>
<%
Response.Write "Hallo " & Request.Form("naam") & " uit " & Request.Form("land")
%>
</BODY>
</HTML>

Gegevens gebruiken met de GET methode
Wanneer de GET methode is gebruikt, kunnen we waardes uitlezen uit de QueryString Collectie van het Request object met de opdracht Request.QueryString("NaamVanWaarde"). Hieronder zie je een voorbeeld van het HTML formulier en vervolgens de code om er wat mee te doen.

form2.asp
<HTML>
<BODY>
<form method="GET" action="form2get.asp">
<table>
<tr>
<td>
Naam
</td>
<td>
<input type="text" name="naam">
</td>
</tr>
<tr>
<td>
Land
</td>
<td>
<input type="text" name="land">
</td>
</tr>
</table>
<input type="submit" value="Verstuur">
<form>
</BODY>
</HTML>

form2get.asp
<%
Option Explicit
%>
<HTML>
<BODY>
<%
Response.Write "Hallo " & Request.QueryString("naam") & " uit " & Request.QueryString("land")
%>
</BODY>
</HTML>

Application object

In de les over variabelen hebben we kunnen zien hoe we variabelen binnen een pagina kunnen gebruiken. Helaas zijn die variabelen niet buiten een pagina beschikbaar en dus niet geschikt om gegevens te delen tussen pagina's. Als we dat willen, dan moeten we gebruik maken van het Application object. Dit object maakt het mogelijk gegevens te delen tussen alle pagina's in een (IIS) applicatie.

Met het Application object kunnen we bijvoorbeeld een teller maken die telt hoe vaak een pagina bezocht is, maar ook kunnen we bijvoorbeeld gegevens over de database koppeling, of andere waarden die we door de hele site nodig hebben, opslaan. We laten zien hoe een teller eruit ziet (ververs de pagina om het resultaat te zien):

appvar1.asp
<%
Option Explicit
%>
<HTML>
<BODY>
<%
Application("Teller") = Application("Teller") + 1
Response.Write Application("Teller")
%>
</BODY>
</HTML>

Stel dat de bovenstaande code tegelijk door twee verschillende mensen bekeken zou worden. Doordat ASP niet alle scripts meteen helemaal afmaakt, maar soms de uitvoering kan stoppen om even een ander script (deels) uit te voeren, zou het zo kunnen zijn dat de waarde die je ziet niet klopt. De waarde zou namelijk opgehoogd kunnen zijn, daarna opgehoogd kunnen zijn door de andere gebruiker en daarna pas in jouw browser geschreven worden. Nou is dit bij een teller niet zo belangrijk, maar het kan zijn dat het wel om informatie gaat die belangrijk is. In dat geval kun je de Lock methode gebruiken om ervoor te zorgen dat er geen andere gebruikers zijn die tegelijk toegang krijgen tot de waardes in het Application object. Omdat dit vertragend werkt moet dit alleen gedaan worden als het nodig is, waarna zo snel mogelijk de Unlock methode wordt gebruikt:
appvar2.asp
<%
Option Explicit
%>
<HTML>
<BODY>
<%
Application.Lock
Application("Teller") = Application("Teller") + 1
Response.Write Application("Teller")
Application.Unlock
%>
</BODY>
</HTML>

Session object

Wat is een sessie?
We praten over een sessie als een gebruiker een pagina van een website opvraagt. Alle pagina's die de gebruiker opent behoren tot dezelfde sessie. Een sessie eindigt als de browser gesloten wordt of als de gebruiker voor een bepaalde tijd geen pagina's meer heeft opgevraagd.
Wat is het Session object?
Binnen een sessie is het handig om gegevens te bewaren die relevant zijn voor de gebruiker, bijvoorbeeld een gebruikersnaam en password zodat we weten of de gebruiker toegang heeft tot bepaalde gegevens. Het zou vervelend zijn als de gebruiker deze gegevens telkens weer op zou moeten geven. We kunnen deze gegevens opslaan in het Session object. Het Session object werkt ongeveer hetzelfde als het Application object, met het verschil dat de gegevens in het Application object voor alle gebruikers "zichtbaar" zijn.

session1.asp
<HTML>
<BODY>
<%
Session("Teller") = Session("Teller") + 1
Response.Write Session("Teller")
%>
</BODY>
</HTML>

Als je de bovenste code meerdere keren zou uitvoeren, zou je denken dat het precies hetzelfde doet als het Application object. Zelfs als je de browser waarin het weergegeven wordt sluit en opnieuw opent, telt de teller gewoon door. Dit komt omdat die browser telkens door de browser waarin je nu leest geopend wordt. Zou je ook deze sluiten en dan een nieuwe browser openen, dan zou er wel een nieuwe sessie zijn en de teller begint dan weer bij 1. Wat je ook kunt doen is een nieuwe browser opstarten (vanuit het Start menu) en dan de pagina nog een keer opvragen.
Hoe werkt het Session object?
De waardes in het Session object worden opgeslagen in het geheugen van de server. Om bij te houden welke sessie van een bepaalde gebruiker is, wordt er een cookie naar de browser gestuurd met een unieke waarde erin: de SessionID. Iedere keer als de browser een aanvraag doet, wordt deze cookie meegestuurd en weet de server welke sessie erbij hoort. Deze cookie wordt ongeldig als de browser gesloten wordt, of er 20 minuten verstreken zijn sinds de laatste aanvraag.

session2.asp
<HTML>
<BODY>
<%
Response.Write Session.SessionID
%>
</BODY>
</HTML>

Browsers die geen cookies accepteren, kunnen ook niet met een sessie werken. Daar komt bij dat als je veel waardes opslaat in het Session object dat dit nadelige gevolgen heeft voor de snelheid van de server. Gebruik het dus alleen als je het echt nodig hebt.
Het Session object heeft nog meer mogelijkheden. Gezien deze erg weinig gebruikt worden, zijn die mogelijkheden geen onderdeel van deze lessen.

Een database openen

Om met een database te kunnen communiceren, moeten we een database connectie hebben. Om deze te maken bevat ADO het Connection object. Nadat we een Connection object hebben aangemaakt, openen we een database met de Open methode. Hierbij vermelden we de database die we willen openen in een zogenaamde ConnectionString.

Een ConnectionString maken
In de ConnectionString specificeren we het type database, de plaats van de database en de database naam. We kunnen eventueel ook een gebruikersnaam en password opgeven. We kunnen ook een gebruikersnaam en password opgeven bij de Open methode. Doen we dit, dan worden eventuele waarden in de ConnectionString genegeerd. Een ConnectionString ziet er als volgt uit:

SQL Server
Provider=sqloledb;Data Source=MijnSQLServer;Initial Catalog=MijnDB;User Id=ik;Password=uhm;

MS Access
Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\databases\MijnDB.mdb;

Lees voor meer informatie het artikel De snelste database verbinding, of ga naar http://www.able-consulting.com/ado_conn.htm voor een lijst met verschillende ConnectionStrings voor verschillende databases.

Voorbeeld
In het onderstaande voorbeeld openen we een database en kijken we of het openen geslaagd is. We hebben de ConnectionString in het Application object opgeslagen, zodat we die niet telkens opnieuw moeten maken. Anders zouden we ook alle pagina's moeten herschrijven als we met een andere database zouden gaan werken.

openconn.asp
<%
Option Explicit

Dim objConn
Dim strResultaat

'Maak Connection object
Set objConn = Server.CreateObject("ADODB.Connection")

'Open database
objConn.Open Application("ConnString")

'Check status
If objConn.State = adStateClosed Then
strResultaat = "De database is niet geopend! Er is iets fout."
Else
strResultaat = "De database is geopend, we sluiten 'm weer af"

'Sluit database
objConn.Close
End If

'Geef Connection object vrij
Set objConn = Nothing
%>
<HTML>
<BODY>
<%
Response.Write strResultaat
%>
</BODY>
</HTML>

In het bovenstaande voorbeeld gebruiken we onder andere de constante adStateClosed. Dit is een constante die voor ADO van belang is. We kunnen echter niet zonder meer gebruik maken van deze constante. Deze moet eerst gedefinieerd worden. Dit kan op drie manieren:

Zelf definiëren met Const adStateClosed = 0
Het bestand adovbs.inc als include bestand aanroepen. Je kunt dit bestand vanuit C:\Program Files\Common Files\System\ado naar je website kopiëren. Vervolgens zet je de volgende regel onderaan je ASP pagina:

Door de Type Library op te geven in global.asa. Je hoeft dan nergens in applicatie een van de andere methoden te gebruiken. Zet de volgende code in global.asa:

Wat is een recordset?

Een recordset is een verzameling records die geretourneerd wordt als we gegevens uit een database opvragen met SQL. ADO bevat het Recordset object, zodat je deze gegevens kunt manipuleren. Je kunt onder andere door de records in een recordset heen bladeren, de records wijzigen of records toevoegen (zolang de cursor niet ReadOnly is), de gegevens opslaan in een bestand, XML of een array.

Wat is een Cursor?
Om door de records heen te kunnen navigeren heeft een recordset een cursor. De cursor staat op het huidige record (mits er records in de recordset zitten). Er zijn verschillende typen cursors, met verschillende mogelijkheden. Hieronder staat een overzicht van de verschillende cursors:

Cursor Eigenschappen
adOpenForwardOnly Alleen van voor naar achter door de recordset bladeren.
Updates van anderen zijn niet zichtbaar.
adOpenStatic Heen en weer bladeren mogelijk.
Updates van anderen zijn niet zichtbaar.
adOpenDynamic Heen en weer bladeren mogelijk.
Updates van anderen zijn zichtbaar.
adOpenKeyset Zoals adOpenDynamic, maar met wat verschillende details.

Een gedetailleerd overzicht van cursor-eigenschappen vind je hier.

Wat is het Lock-type?
Een recordset kan alleen-lezen zijn, of wijzigbaar. Naast alleen-lezen zijn er drie soorten wijzigbare recordsets. Hieronder staat een overzicht met de mogelijke Lock-types:

Lock-type Eigenschappen
adLockReadOnly Alleen lezen
adLockPessimistic Zodra er wijzigingen in een record worden aangebracht, wordt deze gesloten voor andere gebruikers. Wanneer de Update methode wordt aangeroepen, wordt het record in de database gewijzigd en vrijgegeven.
adLockOptimistic Wijzigingen worden doorgevoerd in de database als de Update methode wordt aangeroepen. Pas dan probeert ADO een lock te krijgen.
adLockBatchOptimistic Handig als er meerdere wijzigingen gedaan moeten worden. Eerst pas je alle records in de recordset aan en vervolgens gebruik je de UpdateBatch methode om alle records in één keer te wijzigen in de database.

Welk Cursor- en Lock-type moet ik gebruiken?
Een recordset dat meer mogelijkheden heeft dan nodig is, verspilt behoorlijk wat geheugen en kost snelheid. Het is dus nodig om het beste type recordset te gebruiken voor wat je wilt. Hoef je geen updates te doen, dan gebruik je een ReadOnly recordset. In andere gevallen kun je over het algemeen het beste Optimistic of BatchOptimistic gebruiken.

Binnen ASP is het eigenlijk niet nodig om de wijzigingen van andere gebruikers te zien. Het is daarom verstandig om ForwardOnly of Static te gebruiken waar mogelijk. In deze tabel kun je zien wanneer je over moet schakelen naar Dynamic of Keyset cursors.

Een recordset weergeven

De inhoud van een recordset weergeven kan op meerdere manieren. De makkelijkste en meest gebruikte manier is door de recordset heen bladeren en stuk voor stuk de records naar de browser schrijven. Door de manier waarop ADO met databases om gaat, is dit echter niet de meest efficiënte methode. Een voor ASP betere (snellere) methode is alle records in een array schrijven met een speciaal daarvoor gemaakte functie: GetRows. Omdat het belangrijk is dat je meteen de goede methode leert, geven we daarvan een voorbeeld. Wil je meer informatie hierover lees dan Data ophalen met GetRows.

In het onderstaande voorbeeld openen we een database, halen we de gegevens op met GetRows en geven we vervolgens de gegevens weer in een HTML-tabel.

select.asp
<%
Option Explicit

Dim objConn
Dim objRs
Dim arrRs
Dim strSQL
Dim lngVelden
Dim lngRecords
Dim i, j

'Maak SQL statement
strSQL = "SELECT CompanyName, Address, PostalCode, City, Country FROM Customers""

'Maak Connection object
Set objConn = Server.CreateObject("ADODB.Connection")

'Open database
objConn.Open Application("ConnString")

'Maak Recordset object
Set objRs = Server.CreateObject("ADODB.Recordset")

'Open recordset
objRs.Open strSQL, objConn, adOpenForwardOnly, adLockReadOnly

'Als er records zijn, sla ze op in een array
If Not objRs.EOF Then
arrRs = objRs.GetRows()
lngVelden = UBound(arrRs)
lngRecords = UBound(arrRs, 2)
Else
lngRecords = -1
End If

'Sluit Recordset
objRs.Close

'Geef Recordset object vrij
Set objRs = Nothing

'Sluit database
objConn.Close

'Geef Connection object vrij
Set objConn = Nothing
%>
<HTML>
<BODY>
<TABLE BORDER="1">
<%
For i = 0 To lngRecords
Response.Write "<TR>"
For j = 0 To lngVelden
Response.Write "<TD>" & arrRs(j, i) & "</TD>"
Next
Response.Write "</TR>"
Next
%>
</TABLE>
</BODY>
</HTML>