Paging implementeren met behulp van OFFSET FETCH NEXT in SQL Server

Een database kan honderdduizenden records bevatten. Het is eenvoudig om deze records in te voegen en te selecteren via databasebeheersystemen zoals SQL Server of MySQL enz. Het is echter niet eenvoudig om duizenden records op een enkele webpagina of in een desktoptoepassing weer te geven. Ruimte- en geheugenbeperkingen maken het moeilijk om een ​​groot aantal records in één keer weer te geven.

Een veelvoorkomende oplossing voor een dergelijk probleem is het implementeren van paging. (Let op, dit is geen geheugenoproep die wordt geïmplementeerd door besturingssystemen) Oproepen tijdens het programmeren verwijst naar het weergeven van gegevens via een reeks pagina's. Een willekeurige Google-zoekopdracht kan duizenden resultaten opleveren. Google gebruikt paging om deze resultaten weer te geven. Als u naar beneden scrolt op de Google-pagina met zoekresultaten, ziet u het volgende:

Hier ziet u het aantal pagina's waarin het zoekresultaat is verdeeld. U kunt op de link Volgende klikken om meer pagina's te bekijken.

In dit artikel zullen we zien hoe OFFSET FETCH NEXT-operators kunnen worden gebruikt om paging op front-end-applicaties te implementeren. We beginnen met een eenvoudig voorbeeld met behulp van de OFFSET FETCH NEXT-operator en zullen dan zien hoe het praktisch kan worden gebruikt met behulp van een opgeslagen procedure.

OFFSET FETCH NEXT gebruiken voor paging in SQL Server

SQL Server bevat de operatoren OFFSET &NEXT om paging te implementeren. De OFFSET-operator verschuift het volgende K-aantal zoekresultaten vanaf het begin, terwijl de FETCH NEXT-operator de NEXT N-resultaten ophaalt waarbij K en N gehele getallen zijn.

Dummy-gegevens voorbereiden

Voordat we OFFSET FETCH NEXT in actie kunnen zien, maken we eerst een dummy-database met 200 records. U kunt een werkende database gebruiken als u er 100% zeker van bent dat er een goede back-up van is gemaakt. Voer hiervoor het volgende script uit:

CREATE Database ShowRoom;
GO
USE ShowRoom;

CREATE TABLE Cars
(
id INT PRIMARY KEY IDENTITY,
name VARCHAR(50) NOT NULL,
company VARCHAR(50) NOT NULL,
power INT NOT NULL
)

In het bovenstaande script maken we een dummy-database ShowRoom aan met één tabel genaamd Cars. Laten we enkele dummy-records aan deze database toevoegen. Voer het volgende script uit:

 USE ShowRoom
DECLARE @count INT
SET @count = 1

DECLARE @carname VARCHAR (50)
DECLARE @company_name VARCHAR (50)

 WHILE (@count <= 200)
 BEGIN
	  SET @carname = 'Car - ' + LTRIM(@count)
	  SET @company_name = 'Company - '+ LTRIM(@count)
	  INSERT INTO Cars VALUES (@carname, @company_name, @count * 5)
	  SET @count = @count + 1
END

Bekijk het bovenstaande script goed. Het bovenstaande script voegt 200 dummy-records in de Cars-tabel in. Het script gebruikt een while-lus voor 200 iteraties. Elke iteratie voegt het woord 'Car -' toe aan het iteratienummer en het resultaat wordt ingevoegd in de naamkolom van de Cars-tabel. Evenzo wordt het woord "Bedrijf -" toegevoegd aan het iteratienummer en in elke iteratie in de bedrijfskolom ingevoegd. Ten slotte wordt bij elke iteratie het iteratienummer vermenigvuldigd met 5 en het resultaat wordt ingevoegd in de machtskolom. Als u nu alle records uit de tabel Cars selecteert, ziet u 200 records in de resultatenset. Voer hiervoor de volgende query uit:

SELECT * FROM Cars

Screenshot van het gedeeltelijke resultaat van de bovenstaande query is als volgt. U kunt 200 rijen in het resultaat zien.

OFFSET FETCH NEXT Voorbeeld

Laten we nu eens kijken naar OFFSET NEXT in actie. De syntaxis van OFFSET NEXT is als volgt:

SELECT * FROM Table_Name
ORDER BY COLUMN_NAME/S
OFFSET Number_of_rows_to_Skip ROWS
FETCH NEXT Number_of_rows_to_Fetch ROWS ONLY

Het is belangrijk om hier te vermelden dat u de ORDER BY-clausule moet gebruiken met OFFSET FETCH NEXT-clausules.

Laten we een eenvoudig voorbeeld bekijken van OFFSET FETCH NEXT, waarbij we de gegevens sorteren op de id-kolom van de Cars-tabel, de eerste 20 rijen overslaan en de volgende 10 rijen ophalen. Voer het volgende script uit:

USE ShowRoom
SELECT * FROM Cars
ORDER BY id
OFFSET 20 ROWS
FETCH NEXT 10 ROWS ONLY

In de uitvoer van het bovenstaande script ziet u records met een id-waarde van 21 tot 30, aangezien we de eerste 20 records hebben overgeslagen en de volgende 10 hebben opgehaald.

OFFSET FETCH NEXT gebruiken met opgeslagen procedure

Als u paging implementeert in een front-endtoepassing, zoals een website of een desktoptoepassing, verzendt u normaal gesproken waarden voor paginanummers en paginagroottes naar de server via een opgeslagen procedure. Afhankelijk van de waarde van het paginanummer en de paginagrootte, retourneert de opgeslagen procedure de juiste set rijen. Laten we zo'n opgeslagen procedure schrijven die paginanummer en paginagrootte als parameters neemt en de bijbehorende records retourneert.

Bekijk het volgende script:

USE ShowRoom
GO
CREATE PROC spGetRecordsByPageAndSize
@Page INT,
@Size INT
AS
BEGIN
	SELECT * FROM Cars
	ORDER BY id
	OFFSET (@Page -1) * @Size ROWS
	FETCH NEXT @Size ROWS ONLY
END

In het bovenstaande script maken we een opgeslagen procedure spGetRecordsByPageAndSize waarvoor 2 parameters @Page en @Size nodig zijn. De opgeslagen procedure gebruikt OFFSET FETCH NEXT om records te filteren op een aantal pagina's en paginagrootte. Als het paginanummer bijvoorbeeld 2 is en het formaat 20, dan is de OFFSET:

(2 – 1) * 20 =20

En de waarde voor FETCH next zal gelijk zijn aan de @Size, d.w.z. 20. Daarom worden de records met id 21 tot 40 geretourneerd. Voer het bovenstaande script uit om een ​​opgeslagen procedure te maken.
Zodra u de opgeslagen procedure hebt gemaakt, voert u het volgende script uit om te zien wat wordt geretourneerd wanneer het paginanummer 2 is en de paginagrootte 20 is.

EXECUTE spGetRecordsByPageAndSize 2, 20

De uitvoer van het bovenstaande script ziet er als volgt uit:

Evenzo, als u records voor de 4e pagina wilt ophalen met 15 records per pagina, haalt de volgende query de records op van id 46 tot id 60.

EXECUTE spGetRecordsByPageAndSize 4, 15

De uitvoer van ziet er als volgt uit:

Conclusie

OFFSET FETCH NEXT is een uiterst handig hulpmiddel, vooral als u een groot aantal records gegroepeerd in pagina's wilt weergeven. In dit artikel hebben we gezien hoe het wordt gebruikt in combinatie met een opgeslagen procedure om paging op front-end-applicaties te implementeren.