SQL Server CRUD Operations

I databasprogrammering finns det fyra grundläggande operationer:skapa , läs , uppdatering och ta bort – CRUD operationer. De är det första steget i databasprogrammering.

Termen CRUD dök först upp i James Martins bok 'Managing the Database Environment.' Sedan dess har denna term blivit populär. I den här artikeln kommer vi att utforska CRUD-operationen i termer av SQL Server eftersom operationssyntaxen kan skilja sig från andra relations- och NoSQL-databaser.

Förberedelser

Huvudidén med relationsdatabaser är att lagra data i tabeller. Tabelldata kan läsas, infogas, raderas. På så sätt manipulerar CRUD-operationer tabelldata.

C	C REATE	Infoga rader/rader i en tabell
R	R EAD	Läs (välj) rader/rader från en tabell
U	U PDATE	Redigera rader/rader i tabellen
D	D ELETE	Ta bort rader/rader från tabellen

För att illustrera CRUD-operationerna behöver vi en datatabell. Låt oss skapa en. Den kommer bara att innehålla tre kolumner. Den första kolumnen kommer att lagra landsnamn, den andra kommer att lagra kontinenten för dessa länder och den sista kolumnen kommer att lagra befolkningen i dessa länder. Vi kan skapa den här tabellen med hjälp av T-SQL-satsen och benämna den som TblCountry .

CREATE TABLE [dbo].[TblCountry]
(
	[CountryName]		VARCHAR(50), 
    [ContinentNames]	VARCHAR(50) NULL, 
    [CountryPopulation]		BIGINT NULL 
)

Låt oss nu granska CRUD-operationerna som utförs på TblCountry bord.

C – SKAPA

För att lägga till nya rader i en tabell använder vi INSERT INTO kommando. I det här kommandot måste vi ange namnet på måltabellen och kommer att lista kolumnnamnen inom parentes. Satsstrukturen ska sluta med VALUES:

INSERT INTO TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   ('Germany','Europe',8279000 )

För att lägga till flera rader i tabellen kan vi använda följande typ av INSERT-satsen:

INSERT INTO TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   
('Germany','Europe',8279000 ), 
('Japan','Asia',126800000 ),
('Moroco','Africa',35740000)

Observera att INTO nyckelordet är valfritt och du behöver inte använda det i infogningssatserna.

INSERT  TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   
('Germany','Europe',8279000 ), 
('Japan','Asia',126800000 ),
('Moroco','Africa',35740000)

Du kan också använda följande format för att infoga flera rader i tabellen:

INSERT INTO TblCountry
SELECT 'Germany','Europe',8279000 
UNION ALL
SELECT 'Japan','Asia',126800000 
UNION ALL
SELECT 'Moroco','Africa',35740000

Nu kommer vi att kopiera data direkt från källtabellen till destinationstabellen. Denna metod är känd som INSERT INTO … SELECT uttalande.

INSERT INTO … SELECT kräver att datatyperna för käll- och måltabellerna matchas. I följande INSERT INTO … SELECT-sats infogar vi data från SourceCountryTbl tabellen till TblCountry bord.

Först infogar vi några syntetiska data i SourceCountryTbl tabell för denna demonstration.

DROP TABLE IF EXISTS [SourceCountryTbl]
CREATE TABLE [dbo].[SourceCountryTbl]
(
	[SourceCountryName]		VARCHAR(50), 
    [SourceContinentNames]	VARCHAR(50) NULL, 
    [SourceCountryPopulation]		BIGINT NULL 
	
)


INSERT INTO [SourceCountryTbl] 
VALUES 
('Ukraine','Europe',44009214  ) ,
('UK','Europe',66573504) ,
('France','Europe',65233271)

Nu kommer vi att utföra INSERT INTO … SELECT-satsen.

INSERT INTO TblCountry
SELECT * FROM SourceCountryTbl

Ovanstående infogningssats lade till alla SourceCountryTbl data till TblCountry tabell. Vi kan också lägga till VAR sats för att filtrera select-satsen.

INSERT INTO TblCountry
SELECT * FROM SourceCountryTbl WHERE TargetCountryName='UK'

SQL Server tillåter oss att använda tabellvariabler (objekt som hjälper till att lagra temporära tabelldata i det lokala omfånget) med INSERT INTO … SELECT-satserna. I följande demonstration kommer vi att använda tabellvariabeln som en källtabell:

  DECLARE @SourceVarTable AS TABLE
  ([TargetCountryName]		VARCHAR(50), 
    [TargetContinentNames]	VARCHAR(50) NULL, 
    [TargetCountryPopulation]		BIGINT NULL 
   )


    INSERT INTO @SourceVarTable 
     VALUES 
     ('Ukraine','Europe',44009214  ) ,
     ('UK','Europe',66573504) ,
     ('France','Europe',65233271)


INSERT INTO TblCountry
SELECT * FROM @SourceVarTable

Tips :Microsoft tillkännagav en funktion i SQL Server 2016 som är parallell infogning . Denna funktion tillåter oss att utföra INSERT-operationer i parallella trådar.

Om du lägger till TABLOCK ledtråd i slutet av din insert-sats, SQL Server kan välja en parallell med bearbetningsplanen enligt din servers maximala grad av parallellitet eller kostnadströskeln för parallellitetsparametrar.

Parallell infogningsbearbetning kommer också att minska utförandetiden för infogningssatsen. Men TABLOCK hint kommer att få låset för det insatta bordet under insättningsoperationen. För mer information om den parallella infogningen kan du se Real World Parallel INSERT...SELECT.

Ett annat praktiskt uttalande är SELECT INTO. Denna metod tillåter oss att kopiera data från en tabell till en nyskapad tabell. I följande uttalande, NewCountryTable fanns inte före körningen av frågan. Frågan skapar tabellen och infogar all data från TblCountry bord.

SELECT * INTO NewCountryTable 
FROM TblCountry

Samtidigt kan vi skapa en ny tabell för särskilda kolumner i källtabellen.

I vissa fall måste vi returnera och använda infogade värden från INSERT-satsen. Sedan SQL Server 2005 tillåter INSERT-satsen oss att hämta aktuella värden från INSERT-satsen.

Nu kommer vi att släppa och skapa vår testtabell och lägga till en ny identitetskolumn. Vi kommer också att lägga till en standardbegränsning i denna kolumn. Därmed, om vi inte infogar något explicit värde i denna kolumn, kommer det automatiskt att skapa ett nytt värde.

I följande exempel kommer vi att deklarera en tabell med en kolumn och infoga utdata från SeqID kolumnvärde till denna tabell med hjälp av OUTPUT-kolumnen:

DROP TABLE IF EXISTS TblCountry
CREATE TABLE [dbo].[TblCountry]
(
	[CountryName]		VARCHAR(50), 
    [ContinentNames]	VARCHAR(50) NULL, 
    [CountryPopulation]		BIGINT NULL ,
	SeqID uniqueidentifier  default(newid())
)	



DECLARE @OutputID AS TABLE(LogID uniqueidentifier) 
 
INSERT  TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
OUTPUT INSERTED.SeqId INTO @OutputID
VALUES   
('Germany','Europe',8279000 )

SELECT * FROM @OutPutId

R – Läs

Läs operation hämtar data från en tabell och returnerar en resultatuppsättning med tabellens poster. Om vi vill hämta data från mer än en tabell kan vi använda JOIN-operatorn och skapa en logisk relation mellan tabeller.

SELECT-satsen spelar en enda primär roll i läsningen drift. Den är baserad på tre komponenter:

Kolumn – vi definierar de kolumner som vi vill hämta data från
Tabell – vi ange vilken tabell vi vill hämta data från
Filter – vi kan filtrera de data som vi vill läsa. Den här delen är valfri.

Den enklaste formen av select-satsen är följande:

SELECT column1, column2,...,columnN
FROM table_name

Nu ska vi gå igenom exemplen. Till en början behöver vi en exempeltabell att läsa. Låt oss skapa det:

DROP TABLE  IF EXISTS TblCountry
 GO
CREATE TABLE [dbo].[TblCountry]
(
	[CountryName]		VARCHAR(50), 
    [ContinentNames]	VARCHAR(50) NULL, 
    [CountryPopulation]		BIGINT NULL 
)

GO
INSERT INTO TblCountry  
(CountryName,ContinentNames,CountryPopulation) 
VALUES   
('Germany','Europe',8279000 ), 
('Japan','Asia',126800000 ),
('Moroco','Africa',35740000)

Läser alla kolumner i tabellen

Operatorn asterisk (*) används i SELECT-satserna eftersom den returnerar alla kolumner i tabellen:

SELECT * FROM TblCountry

Tips :Operatören asterisk (*) kan påverka prestandan negativt eftersom den orsakar mer nätverkstrafik och förbrukar mer resurser. Således, om du inte behöver få alla data från alla kolumner returnerade, undvik att använda asterisken (*) i SELECT-satsen.

Läser specifika kolumner i tabellen

Vi kan också läsa särskilda kolumner i tabellen. Låt oss granska exemplet som endast returnerar CountryName och CountryPopulation kolumner:

SELECT CountryName,CountryPopulation FROM TblCountry

Använda alias i SELECT-satserna

I SELECT-satserna kan vi ge temporära namn till tabellen eller kolumnerna. Dessa tillfälliga namn är alias. Låt oss skriva om de två föregående frågorna med tabell- och kolumnalias.

I följande fråga, TblC alias kommer att ange tabellnamnet:

SELECT TblC.* FROM TblCountry TblC

I följande exempel kommer vi att tillhandahålla alias för kolumnnamnen. Vi ändrar Landsnamn till CName och CountryPopulation – till CPop .

SELECT TblC.CountryName AS [CName], CountryPopulation AS [CPop] FROM TblCountry TblC

Ändamålen med aliaset är:

Gör frågan mer läsbar om tabell- eller kolumnnamnen är komplexa.
Se till att du använder en fråga för tabellen mer än en gång.
Förenkla frågeskrivningen om tabellen eller kolumnnamnet är långt.

Filtrera SELECT-satser

SELECT-satser låter oss filtrera resultatuppsättningarna genom WHERE-satsen. Till exempel vill vi filtrera SELECT-satsen enligt CountryName kolumnen och returnerar endast data från Tyskland till resultatuppsättningen. Följande fråga kommer att utföra läsoperationen med ett filter:

SELECT TblC.* FROM TblCountry TblC
WHERE TblC.CountryName='Germany'

Sortera SELECT-satsresultat

ORDER BY-satsen hjälper oss att sortera resultatuppsättningen av SELECT-satsen efter den eller de angivna kolumnerna. Vi kan utföra stigande eller fallande sortering med hjälp av ORDER BY-satsen.

Vi sorterar TblCountry tabell enligt ländernas befolkning i stigande ordning:

SELECT TblC.* FROM TblCountry TblC
ORDER BY TblC.CountryPopulation ASC

Tips :Du kan använda kolumnindex i ORDER BY-satsen, och kolumnindexnummer börjar med 1.

Vi kan också skriva den föregående frågan. Siffran tre (3) indikerar landsbefolkningen kolumn:

SELECT TblC.* FROM TblCountry TblC
ORDER BY 3 ASC

U – Uppdatering

UPDATE-satsen modifierar befintliga data i tabellen. Denna sats måste inkludera SET-satsen så att vi kan definiera målkolumnen för att modifiera data.

Följande fråga kommer att ändra alla rader i landsbefolkningen kolumnvärdet till 1.

UPDATE TblCountry SET CountryPopulation=1
GO
SELECT TblC.* FROM TblCountry TblC

I UPDATE-satserna kan vi använda WHERE-satsen för att ändra en viss rad eller rader i tabellen.

Låt oss ändra Japan rad med landsbefolkning till 245 000:

UPDATE TblCountry SET CountryPopulation=245000
WHERE CountryName = 'Japan'
GO
SELECT TblC.* FROM TblCountry TblC

UPDATE-satsen är en förening av delete- och insert-satserna. Så vi kan returnera de infogade och raderade värdena genom OUTPUT-satsen.

Låt oss ta ett exempel:

UPDATE TblCountry SET CountryPopulation=22
OUTPUT inserted.CountryPopulation AS [Insertedvalue],
deleted.CountryPopulation AS [Deletedvalue]
WHERE CountryName = 'Germany'

Som du kan se har vi ändrat landsbefolkningen värde från 1 till 22. Sedan kan vi ta reda på de infogade och raderade värdena. Dessutom kan vi infoga dessa värden i en tabellvariabel (en speciell variabeltyp som kan användas som tabell).

Vi kommer att infoga de infogade och raderade värdena i tabellvariabeln:

DECLARE @LogTable TABLE(InsertValLog INT , DelValLog INT) 


UPDATE TblCountry SET CountryPopulation=45
OUTPUT inserted.CountryPopulation ,
deleted.CountryPopulation INTO @LogTable
WHERE CountryName = 'Germany'


SELECT * FROM @LogTable

@@ROWCOUNT är en systemvariabel som returnerar antalet rader som påverkas i den sista satsen. Därför kan vi använda denna variabel för att exponera några modifierade rader i uppdateringssatsen.

I följande exempel kommer uppdateringsfrågan att ändra 3 rader och systemvariabeln @@ROWCOUNT returnerar 3.

UPDATE TblCountry SET CountryPopulation=1
SELECT @@ROWCOUNT AS [AffectedRowNumber]

D – Ta bort

Delete-satsen tar bort befintliga rader från tabellen.

Låt oss först se hur man använder WHERE-satsen i DELETE-satserna. Oftast vill vi filtrera bort rader.

Exemplet nedan illustrerar hur man tar bort en viss rad:

SELECT TblC.* FROM TblCountry TblC
DELETE FROM TblCountry WHERE CountryName='Japan'
SELECT TblC.* FROM TblCountry TblC

Men med DELETE-satsen kan vi ta bort alla poster från tabellen. DELETE-satsen är dock väldigt grundläggande och vi använder inte WHERE-villkoret.

SELECT TblC.* FROM TblCountry TblC
DELETE FROM TblCountry
SELECT TblC.* FROM TblCountry TblC

Ändå, under vissa omständigheter av databasens design, raderar DELETE-satsen inte raden/raderna om den bryter mot främmande nycklar eller andra begränsningar.

Till exempel i AdventureWorks databas kan vi inte ta bort rader i Produktkategorin tabell eftersom ProductCategoryID anges som en främmande nyckel i den tabellen.

Låt oss försöka ta bort en rad från ProductCategory tabell – utan tvekan kommer vi att möta följande fel:

DELETE FROM [Production].[ProductCategory]
WHERE ProductCategoryID=1

Slutsats

Därför har vi utforskat CRUD-operationerna i SQL. INSERT-, SELECT-, UPDATE- och DELETE-satserna är de grundläggande funktionerna i SQL-databasen, och du måste behärska dem om du vill lära dig SQL-databasprogrammering. CRUD-teorin kan vara en bra utgångspunkt, och mycket övning hjälper dig att bli expert.