SQL-referenstabell:Hur man skapar och skriver grundläggande frågor

Den här artikeln kommer att fokusera på att skriva SQL-frågor mot databasens referenstabell med en ganska enkel struktur att förstå och implementera.

Dessutom kommer vi att klargöra koncepten bakom att skriva effektiva SQL-frågor tillsammans med några tips för yrkeslivet.

Innan du frågar efter databastabellerna

Eftersom den här artikeln handlar om att söka efter databastabeller med hjälp av SQL-skript bör läsarna ha en viss bakgrund för att helt förstå begreppen och exemplen. Vi måste ha intrycket av hur man refererar till en tabell. Dessutom måste nödvändig utrustning finnas:

Du behöver:

Grundläggande kunskaper om relationsdatabaser och SQL.
En SQL-databasserver installerad lokalt eller på distans.
Databashanteringsverktyg som SQL Server Management Studio eller dbForge Studio för SQL Server.

Du bör kunna skapa en exempeldatabas (med hjälp av medföljande skript), ansluta till SQL Server och köra mot den exempeldatabasen.

Innan vi fortsätter att köra frågor mot en tom databas, kan du behöva hänvisa till den tidigare artikeln dedikerad till ämnet för att uppdatera kunskapen:

Hur man skriver enkla SQL-frågor från en tom databas

Skriva SQL-frågor med början från referenstabeller

Vi behöver skriva SQL-frågor mot en exempeldatabas som innehåller två tabeller. Planen är att se data från en av tabellerna som kallas en SQL-referenstabell. Obs:Referenstabellen kan vara vilken tabell som helst som inte kräver data från en annan tabell.

Först måste vi förstå strukturen för exempeldatabasen för att fråga den korrekt.

Exempel på databasreferenstabell

Vi använder ett exempel på BookSimple2 databas som består av två tabeller, BookType och Boka .

BookType Tabellen innehåller de typer av böcker som ska tilldelas en bok. boken Tabellen innehåller namn, typer och lager (antal tillgängliga exemplar) av böcker.

Det är lätt att gissa att båda tabellerna är länkade via nycklar. Typen av bok som lagras i boken tabellen är ursprungligen definierad i BookType tabell. Det gör det möjligt att hålla data konsekvent och tillförlitlig.

Därför är BookType tabellen är en referenstabell – den tillhandahåller sin referens (boktyp) till huvud boken bord.

Ta en titt på illustrationen nedan:

Om vi inte länkar boken tabell med BookType för att få typ av bok måste vi definiera den nödvändiga typen varje gång en ny bok lagras. Som ett resultat kommer fel snart att uppstå eftersom vi lagrar samma typ om och om igen. Dessutom kan vi skapa många fler typer på grund av stavfel.

Låt oss säga att om vi ignorerar användningen av referenstabeller och bara skapar en huvudtabell, kan vi använda olika sätt att representera en typ, till exempel Design , Designa och Designer . Det förvirrar, särskilt när man frågar och förstår data.

Du kan också hänvisa till den tidigare artikeln för mer information om hur tabeller relaterar till varandra i SQL:

Lär dig databasdesign med SQL Server Management Studio (SSMS) – Del 2

Nu när du ser bakgrunden till att använda referenstabellerna och huvudtabellerna kan vi gå vidare till exempel.

Hur man skapar en referenstabell i SQL

Öppna databasutvecklingsverktyget (det kan vara SQL Server Management Studio eller dbForge Studio för SQL Server) och anslut till den installerade SQL-serverinstansen.

Skriv följande skript mot huvuddatabasen för att skapa en exempeldatabas BookSimple2 med två tabeller:

-- Create sample database BookSimple2
USE MASTER
GO

CREATE DATABASE BookSimple2
GO

USE BookSimple2

-- Creating a reference table BookType
CREATE TABLE dbo.BookType
(
	BookTypeId INT IDENTITY(1,1),
	Name VARCHAR(50)NOT NULL,
	Detail VARCHAR(200)NULL 
	CONSTRAINT PK_BookType_BookTypeId PRIMARY KEY (BookTypeId)
)
GO

-- Populating (adding rows to the) table BookType
SET IDENTITY_INSERT dbo.BookType ON
GO
INSERT INTO dbo.BookType
(
  BookTypeId
 ,Name
 ,Detail
)
VALUES
(
  1  -- ID - INT Primary Key
 ,'Designing' -- Name - varchar(50) NOT NULL
 ,'This is Designing' -- Detail - varchar(200)
),
(
  2  -- ID - INT Primary Key
 ,'Testing' -- Name - varchar(50) NOT NULL
 ,'This is Testing' -- Detail - varchar(200)
),
(
  3  -- ID - INT Primary Key
 ,'Coding' -- Name - varchar(50) NOT NULL
 ,'This is Coding' -- Detail - varchar(200)
);
GO
SET IDENTITY_INSERT dbo.BookType OFF
GO

-- Creating a table Book
CREATE TABLE dbo.Book
(
	BookId INT IDENTITY(1,1),
	Name VARCHAR(50),
	BookTypeId INT,
	Stock INT,
	CONSTRAINT PK_Book_BookId PRIMARY KEY (BookId)
)
GO

Efter att ha kört skriptet kan du se den nyskapade databasen i SSMS Object Explorer eller Database Explorer-delen av dbForge Studio för SQL Server:

Hur man refererar till två tabeller med SQL Foreign Key

Jag har medvetet uteslutit den del av skriptet som skapar relationen mellan referenstabellen (BookType ) och huvudtabellen (Boka ) i form av nycklar.

Kör följande skript mot exempeldatabasen för att länka referenstabellen med huvudtabellen:

-- Creating foreign key constraint on Book table to get BookTypeId values from BookType table
ALTER TABLE dbo.Book
    ADD CONSTRAINT [FK_Book_BookType_BookTypeId] 
FOREIGN KEY ([BookTypeId]) REFERENCES dbo.[BookType] ([BookTypeId]);

Expandera BookSimple2 databas> Bok tabell> Nycklar mapp:

Vi kan se att de två tabellerna är framgångsrika länkade.

Ovanstående är skärmdumpen från SQL Server Management Studio. Vyn är dock exakt densamma om du visar databasen i Database Explorer i dbForge Studio för SQL Server.

Ett viktigt tips om att välja önskad databas: Du måste se till att du kör frågor mot rätt databas – exempeldatabasen. Välj därför det från listan över tillgängliga databaser eller kör följande skript:

-- Select the sample SQL database to query it
USE BookSimple2

Viktig! Användningen av ett skript för att välja databasen är inte tillämpligt om du arbetar med en molnversion av SQL-databasen som kallas Azure SQL Database.

Skriv första frågan

För att fråga databastabellerna behöver vi bara tänka på SELECT-satsen i följande form:

SELECT * FROM <TableName>

Ersätt med namnet på en befintlig tabell, och skriptet kommer att returnera alla poster (rader) i den tabellen.

SELECT-satsen är mycket mer flexibel, men för närvarande fokuserar vi bara på att se alla poster (rader) i en tabell.

Ett viktigt tips om SQL :Kom ihåg att SQL (särskilt med hänvisning till T-SQL) inte är skiftlägeskänslig . Det relaterar till både det SQL-reserverade ordet (SELECT är detsamma som Välj ) eller användardefinierade namn (BookType är samma som boktyp ) .

Visa alla rader från BookType-referenstabellen

Skriv följande skript mot exempeldatabasen:

-- View all data from the BookType table
SELECT * FROM dbo.BookType

Utdata är:

Vi kan se alla kolumner och rader från tabellen. Det är den överlägset snabbaste metoden att hämta all data från en tabell.

Viktigt tips om SELECT *: Du bör använda SELECT * för att få alla rader och kolumner från en tabell endast när du kontrollerar en liten tabell (som en referenstabell). Annars kan det ta mycket tid, medan vi kan behöva data på några kolumner och rader från en större tabell.

Hitta alla rader från BookType-tabellen med hjälp av tabellnamnet

Det finns ett bättre sätt att fråga i tabellen. Vi namnger en tabell och binder den med alla kolumner enligt nedan:

-- View all data from the BookType table using bt alias
SELECT bt.* FROM dbo.BookType bt

Visa valda kolumner från referenstabell

Att använda tabellnamn ger fler fördelar. Först kan vi snabbt välja önskad kolumn från tabellen. Då blir det tydligare att använda tabeller och begränsade kolumner eftersom vi i de flesta fall bara kräver några kolumner.

Här är ett exempel på att få ID:n och namn endast från BookType tabell:

-- View book type id and name columns from the reference table
SELECT bt.BookTypeId,bt.Name FROM dbo.BookType bt

Resultatet är:

Förbättra SELECT-syntaxen

Därför kan vi, baserat på informationen som nämns ovan, förbättra SELECT-syntaxen enligt följande:

SELECT t.<column1>,t.<column2> FROM <TableName> t

Sortera data efter namnkolumn med hjälp av Order By-klausulen

Du kan sortera resultatuppsättningen baserat på en specifik kolumn eller uppsättning kolumner. Sortering av data ger en annan synvinkel.

Användningen av Beställ efter klausul i detta fall är:

SELECT t.<column1>,t.<column2> FROM <TableName> t order by t.<column1>

Till exempel vill vi se boktyperna sorterade efter typnamnet (alfabetisk ordning). I det här fallet använder vi Order By-satsen i SELECT-satsskriptet enligt följande:

-- View book types (name) sorted by type name 
SELECT bt.Name FROM dbo.BookType bt ORDER BY bt.Name

Utdata är:

Sortera data efter namnkolumn i fallande ordning

Vi kan också sortera uppgifterna i fallande ordning enligt krav. Till exempel vill vi se listan över alla boktyper baserat på namnkolumnen i fallande ordning (Z till A). Syntaxen blir:

SELECT t.<column1>,t.<column2> FROM <TableName> t order by t.<column1> desc

T-SQL-skriptet är som följer:

-- View book types (name) sorted by a type name in descending order (from Z to A)
SELECT bt.Name FROM dbo.BookType bt ORDER BY bt.Name desc

Resultatuppsättningen är nedan:

Visa TOP N-poster från en tabell

Slutligen kan vi välja önskat antal rader som ska hämtas från en databas genom att använda TOP-satsen. Efter den klausulen måste vi tillhandahålla det nödvändiga numret:

SELECT Top N t.<column1>,t.<column2> FROM <TableName> t

TOP-satsen utan någon ordning är dock inte det bästa alternativet. Vi måste ange ordningen på kolumner som ska beaktas när vi väljer de n översta raderna.

Här kan vi förbättra ovanstående syntax enligt följande:

SELECT Top N t.<column1>,t.<column2> FROM <TableName> t order by <column> Desc/Asc

Kom ihåg att vi måste nämna den fallande ordningen genom att använda DESC i slutet. Den stigande ordningen är dock inte obligatorisk att nämna – det är standardalternativet.

Låt oss se de två bästa typerna av böcker sorterade efter namn i fallande ordning:

--View Top 2 types of the books ordered by name in descending order (from Z to A)
SELECT TOP 2 bt.Name FROM dbo.BookType bt 
ORDER BY bt.Name DESC

Utdata är:

Viktigt tips om TOPP N: använd TOP N-satsen (med en ordning efter) för att visa en tabell istället för att visa alla rader i tabellen om du snabbt vill kontrollera data som kallas en smygtitt.

I yrkesscenarier tjänar Top N-satsen till att uppdatera stora databitar från en stor tabell i steg.

Nu har vi framgångsrikt frågat tabellen i en SQL-databas. Dessutom har vi blivit bekanta med några tips för att köra frågor som en professionell och lärt oss några bästa metoder för att skriva SQL-frågor.

Övning för DB Referenstabell

Nu kan du skriva, köra och öka effektiviteten hos SQL-frågor mot vilken tabell som helst. Prova följande övningar för att förbättra de nya färdigheterna:

Försök att skriva ett skript för att visa boktyps-id (BookTypeId ) med detaljerna (Detaljer ) endast kolumner.
Försök att sortera referensen boktyp tabell efter id (BookTypeId ) i fallande ordning (från 3 till 1).
Försök att hämta de två översta raderna från BookType tabell inklusive endast id (BookTypeId ) och detaljer (Detaljer ) av boktypen sorterad efter Detalj kolumn.