Implementering af personsøgning ved hjælp af OFFSET FETCH NEXT i SQL Server

En database kan have hundredtusindvis af poster. Det er nemt at indsætte og vælge disse poster via databasestyringssystemer som SQL Server eller MySQL osv. Det er dog ikke nemt at vise tusindvis af poster på en enkelt webside eller i en desktopapplikation. Plads- og hukommelsesbegrænsninger gør det vanskeligt at vise et stort antal poster på én gang.

En almindelig løsning på et sådant problem er at implementere personsøgning. (Bemærk, dette er ikke hukommelsessøgning implementeret af operativsystemer) Personsøgning i programmering refererer til visning af data via en række sider. En tilfældig Google-søgning kan resultere i tusindvis af resultater. Google bruger personsøgning til at vise disse resultater. Hvis du ruller ned på Google-siden med søgeresultater, vil du se følgende:

Her kan du se antallet af sider, som søgeresultatet er opdelt i. Du kan klikke på næste link for at se flere sider.

I denne artikel vil vi se, hvordan OFFSET FETCH NEXT-operatører kan bruges til at implementere personsøgning på front-end-applikationer. Vi begynder med et simpelt eksempel ved at bruge OFFSET FETCH NEXT operatoren og vil derefter se, hvordan den praktisk kan bruges ved hjælp af en lagret procedure.

Brug af OFFSET FETCH NEXT til Paging i SQL Server

SQL Server indeholder OFFSET &NEXT-operatørerne til at implementere personsøgning. OFFSET-operatoren forskyder det næste K antal søgeresultater fra begyndelsen, mens FETCH NEXT-operatoren henter NEXT N-resultaterne, hvor K og N er heltal.

Forberedelse af dummy-data

Før vi kan se OFFSET FETCH NEXT i aktion, lad os oprette en dummy-database med 200 poster. Du kan bruge en fungerende database, hvis du er 100 % sikker på, at den er sikkerhedskopieret korrekt. Udfør følgende script for at gøre det:

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
)

I scriptet ovenfor opretter vi en dummy-database ShowRoom med en tabel kaldet Cars. Lad os tilføje nogle dummy-poster i denne database. Udfør følgende script:

 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

Tag et omhyggeligt kig på ovenstående script. Ovenstående script indsætter 200 dummy-poster i tabellen Biler. Scriptet bruger en while-løkke til 200 iterationer. Hver iteration tilføjer ordet 'Car -' til iterationsnummeret, og resultatet indsættes i navnekolonnen i Cars-tabellen. På samme måde tilføjes ordet "Virksomhed -" med iterationsnummeret og indsættes i firmakolonnen i hver iteration. Til sidst, ved hver iteration, ganges iterationstallet med 5, og resultatet indsættes i potenskolonnen. Hvis du nu vælger alle posterne fra Biler-tabellen, vil du se 200 poster i resultatsættet. Udfør følgende forespørgsel for at gøre det:

SELECT * FROM Cars

Skærmbillede af det delvise resultat af ovenstående forespørgsel er som følger. Du kan se 200 rækker i resultatet.

OFFSET FETCH NEXT Eksempel

Lad os nu se på OFFSET NEXT i aktion. Syntaksen for OFFSET NEXT er som følger:

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

Det er vigtigt at nævne her, at du skal bruge ORDER BY-klausulen med OFFSET FETCH NEXT-klausuler.

Lad os se et simpelt eksempel på OFFSET FETCH NEXT, hvor vi vil sortere dataene efter id-kolonnen i Cars-tabellen, springe de første 20 rækker over og hente de næste 10 rækker. Udfør følgende script:

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

I outputtet af scriptet ovenfor vil du se poster med en id-værdi på 21 til 30, da vi sprang de første 20 poster over og hentede de næste 10.

Brug af OFFSET FETCH NEXT med Stored Procedure

Hvis du implementerer personsøgning i en frontend-applikation såsom et websted eller en desktop-applikation, vil du typisk sende sidetal og sidestørrelsesværdier til serveren via en lagret procedure. Afhængig af værdien af ​​sidetallet og sidestørrelsen, vil den lagrede procedure returnere det korrekte sæt rækker. Lad os skrive sådan en lagret procedure, som tager sidetal og sidestørrelse som parametre og returnerer de tilsvarende poster.

Tag et kig på følgende 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

I scriptet ovenfor opretter vi en lagret procedure spGetRecordsByPageAndSize, der tager 2 parametre @Page og @Size. Den lagrede procedure bruger OFFSET FETCH NEXT til at filtrere poster efter et antal sider og sidestørrelse. For eksempel, hvis sidetallet er 2, og størrelsen er 20, vil OFFSET være:

(2 – 1) * 20 =20

Og værdien for FETCH næste vil være lig med @Size, dvs. 20. Derfor vil posterne med id 21 til 40 blive returneret. Udfør ovenstående script for at oprette en lagret procedure.
Når du har oprettet den lagrede procedure, skal du udføre følgende script for at se, hvad der returneres, når sidetallet er 2 og sidestørrelsen er 20.

EXECUTE spGetRecordsByPageAndSize 2, 20

Outputtet af ovenstående script ser sådan ud:

På samme måde, hvis du ønsker at hente poster for den 4. side med 15 poster pr. side, henter følgende forespørgsel posterne fra id 46 til id 60.

EXECUTE spGetRecordsByPageAndSize 4, 15

Outputtet af ser sådan ud:

Konklusion

OFFSET FETCH NEXT er et yderst nyttigt værktøj, især hvis du ønsker at vise et stort antal poster grupperet i sider. I denne artikel så vi, hvordan det bruges sammen med en lagret procedure til at implementere personsøgning på frontend-applikationer.