Hvis du har arbejdet med relationsdatabasesystemer, er det sandsynligt, at du har hørt om populære databasesystemer som f.eks MySQL , Server eller PostgreSQL . SQLite er en anden ekstremt nyttig RDBMS, der er meget enkel at konfigurere og betjene. Det har også mange forskellige funktioner i forhold til andre relationsdatabaser. Denne SQLite-tutorial lærer grundlæggende begreber, som du har brug for at kende ved hjælp af omfattende praktisk praksis.
Emnerne diskuteret i denne artikel er:
SQLite Tutorial: Hvad er SQLite?
Her er industristandarddefinitionen af SQLite:
SQLite er en open source, nulkonfiguration, selvstændig, stand-alone, transaktionsrelationel databasemotor designet til at blive integreret i en applikation.Du kan overveje SQLite som en ' lettere ”Version af andre komplekse RDBMS (Oracle, osv.), hvor databasemotoren er konfigureret til uafhængig behandling (in-process bibliotek) dvs. a serverfri, selvstændig, nulkonfiguration og transaktionel . Det er kendt for sin bærbarhed, pålidelighed og stærke ydeevne selv i miljøer med lav hukommelse. SQLite er også et populært valg som en integreret database til lokal / klientlagring i slutprogrammer eller applikationer, i modsætning til andre RDBMS, hvor klientserver-DB-motoren er konfigureret.
Funktioner i SQLite
SQLite tilbyder mange forskellige funktioner såsom:
- Serverløs: Mest SQL-databaser implementeres som en separat serverproces, men SQLite har ikke en separat serverproces. Det er en serverløs databasemotor. Den læser og skriver direkte til almindelige diskfiler.
- Nulkonfiguration: Detkræver ingen konfiguration for at få den til at køre. Dette betyder, at der ikke er nogen serverproces, der skal startes, stoppes eller konfigureres som i et klient / serversystem.
- Manifest typing: SQLite bruger manifesttypning, som tillader lagring af en hvilken som helst mængde af enhver datatype i en hvilken som helst kolonne, uanset kolonnens erklærede datatype. Bemærk, at der er visse undtagelser fra denne regel.
- Letvægt: Som navnet antyder, SQLite-biblioteket er meget let. Sagen er, selvom den plads, den bruger, varierer afhængigt af systemet, hvor den er installeret, kan den tage mindre end 600 KB plads.
- Transportabel: I modsætning til andre DBMS er enhele SQLite-databasen er gemt i en enkelt fil.Denne fil kan deles via flytbare medier eller filoverførselsprotokoller meget let.
- Diverse valg: Mange programmeringssprog indeholder bindinger til SQLite, inklusive , , C # , , , Rubin , , og mange flere.
- Gratis: SQLite er gratis og open source. For at arbejde med SQLite kræves der ikke en kommerciel licens.
Som anført ovenfor SQLiteer kendt for sin nulkonfiguration, hvilket betyder, at der ikke kræves nogen kompleks opsætning eller administration. I den næste del af denne SQLite-selvstudie skal vi se, hvordan du installerer SQLite på dit system.
SQLite Tutorial: Installation af SQLite på Windows
De trin, der skal følges, er:
Trin 1: Gå til officiel SQLite websted og klik på det passende link for at downloadeprækompilerede binære filer.
Trin 2: Download SQLite-kommandolinjens zip-fil (her: sqlite-tools-win32-x86-3270200.zip) og udvid disse filer i en mappe efter eget valg.
Dette SQLite-kommandolinjeværktøj indeholder følgende SQLite-produkter
- SQLite-kerne : SQLite-kernen indeholder den aktuelle databasemotor og den offentlige API.
- SQLite3 kommandolinjeværktøj : Sqlite3-applikationen er et kommandolinjeværktøj, der er bygget oven på SQLite-kernen.
- Tcl udvidelse : Dette bibliotek er i det væsentlige en kopi af SQLite-kernen med Tcl-bindingerne fastgjort.
- SQLite-analysatorværktøj : SQLite-analysatorværktøjet bruges til at analysere databasefiler.
Trin 3: Derefter er initiering af SQLite-kommandolinjen så simpelt som at klikke på sqlite3-applikationen, hvilket får kommandolinjen til at dukke op.
Hvis du vil teste videre, skal du blot skrive .Hjælp kommando fra sqlite> bede om at se alle tilgængelige kommandoer i sqlite3 som vist nedenfor.
Bemærk: Som standard bruger en SQLite-session databasen i hukommelsen, derfor vil alle ændringer være væk, når sessionen slutter.
Enkelt nok, ikke? Lad os så komme i gang med SQLite-kommandoer.
SQLite-tutorial: SQLite-kommandoer
Dette afsnit af SQLite-selvstudiet præsenterer grundlæggende SQL-sætninger, som du kan bruge sammen med SQLite.
Bemærk: SQLite-kommandoer slutter med et semikolon (). Det fortæller SQLite, at din kommando er komplet og skal køres.Du kan også sprede din kommando på tværs af flere linjer og bruge semikolon på den sidste linje.
Databasekommandoer
Dette afsnit består af disse kommandoer, som du kan håndtere din database med. Kommandoerne er:
- SQLite Opret database
SQLite bruger ikke CREATE DATABASE-sætningen som i andre relationsdatabasesystemer, f.eks MySQL , SQL Server osv. For at oprette en ny database i SQLite skal du blot indtaste sqlite3 efterfulgt af navnet på den fil, du vil bruge til databasen. Tden følgende kode opretter en databasefil kaldet StudentDetails.db:
Eksempel
sqlite3 StudentDetails.db sqlite> .databases main: D: sqliteStudentDetails.db
- SQLite Vedhæft database
Når du har flere databaser, kan du kun bruge en ad gangen. I SQLite bruges ATTACH DATABASE-sætningen til at vedhæfte en bestemt database til den aktuelle forbindelse. ENEfter denne kommando udføres alle SQLite-udsagn under den vedhæftede database.
Eksempel
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department' sqlite> .databases main: D: sqliteStudentDetails.db Department: D: sqliteDepartmentDetails.db
- SQLite frigør database
I SQLite bruges DETACH DATABASE-sætningen til at løsne den alias-navngivne database fra en databaseforbindelse, der tidligere var vedhæftet ved hjælp af ATTACH-sætningen. Hvis den samme databasefil er vedhæftet med flere aliaser, vil denne kommando kun afbryde det givne navn, og resten af vedhæftningen vil fortsat eksistere.Databaserne i den indbyggede eller midlertidige database ødelægges fuldstændigt, og indholdet går tabt.
Eksempel
sqlite> .databases main: D: sqliteStudentDetails.db Afdeling: D: sqliteDepartmentDetails.db Studerende: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department' sqlite> .database main: Database main: Dbdatabase main: Studerende: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db
Tabelkommandoer
Her vil vi lære at håndtere tabeller, når du bruger SQLite.
- SQL Opret tabel
I SQLite bruges CREATE TABLE-sætningen til at oprette en ny tabel. Mens du opretter tabellen, skal du navngive tabellen og definere dens kolonne og datatyper for hver kolonne.
Syntaks:
OPRET TABEL tabelnavn (Kolonne1 kolonnetype [begrænsninger] Kolonne2 kolonnetype [begrænsninger] [.....])
Eksempel
OPRET TABEL StudentInfo (ID INT PRIMÆR NØGLE IKKE NULL, NAVN TEKST IKKE NULL, ALDER INT IKKE NULL, ADRESSE CHAR (50), DEPARTMENTID INTEGER IKKE NULL, TELEFON TEKST STANDARD 'Ukendt', UDENLANDSK Nøgle (AFDELING)) Referencer
Du kan kontrollere, om tabellen blev oprettet eller ikke ved hjælp af .tabeller kommando som vist nedenfor. Bemærk, at jeg allerede har oprettet en tabel, der hedder DepartmentInfo hvor DeptID er den primære nøgle.Afdelingstabellen har en udenlandsk nøglebegrænsning til tabellen Studerende.
sqlite> .tables StudentInfo Kontakter Emp_Master
- SQLite Drop Table
I SQLite giver DROP TABLE-sætningen dig mulighed for at fjerne eller slette en tabel fra SQLite-databasen. Når tabellen er droppet, fjernes alle de data, den indeholder, permanent fra databasen. Eventuelle tilknyttede indekser og udløsere fjernes også. Hvis der er nogen fremmed nøglebegrænsning aktiveret på den pågældende tabel, fjernes den ækvivalent for hver række i tabellen, og eventuelle udløsere, der er knyttet til tabellen, slettes også.
Syntaks
DROPTABEL [HVIS DET FINDER] tabelnavn
Eksempel
DROP-TABEL Afdelingsfejl: ingen sådan tabel: Afdeling DROP-TABEL Virksomhed sqlite> .tabeller StudentInfo
Bemærk: IF EXISTS er en valgfri klausul. Hvis angivet, vil DROP TABLE-sætningen ikke rejse en fejl, hvis en af tabellerne ikke findes.
Der er også en SQLite Alter Table-sætning , som vi vil forstå i de næste par afsnit i denne artikel. Nu hvor vi har oprettet en tabel, skal vi se, hvordan data indsættes, slettes og ændres.
SQLite-tutorial: CRUD-operationer
- SQLite Indsæt forespørgsel
Efter oprettelse af tabellen kan kommandoen SQLite Indsæt i bruges til at oprette nye rækker i den angivne tabel. Der er to meningsfulde former for SQLite-indsætningserklæringen. Den første formular bruger en VALUES-sætning til at specificere en liste over værdier, der skal indsættes.
Syntaks
INSERT INTO TABLE_NAME [(column1, column2, column3, ... columnN)] VALUES (value1, value2, value3, ... valueN)
Eksempel
INDSÆT I StudentInfo (ID, NAVN, ALDER, ADRESSE, AFDELING, TELEFON) VÆRDIER (1, 'Dean', 20, 'Californien', 2, '934 *******')
Produktion
VÆLG * fra StudentInfo ID NAVN ALDER ADRESSE AFDELING TELEFON ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 Californien 2934 *******
Her oprettes en enkelt ny række, og hver værdi registreres i sin respektive kolonne. Bemærk, at begge lister skal have samme antal stk. Her, den liste over kolonnerne er valgfri. Vi kan også indsætte data i tabellen uden at angive listen over kolonner .
Eksempel
INDSÆT I StudentInfo-VÆRDIER (2, 'SAM', 22, 'Texas', 2, '976 *******')
Produktion
VÆLG * fra StudentInfo ID NAVN ALDER ADRESSE AFDELING TELEFON ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 Californien 2934 ******* 2 SAM 22 Texas 2996 *******
SQLite tilbyder også en funktion til indsæt flere rækker i en enkelt INSERT-erklæring. Syntaksen er som vist nedenfor.
Eksempel
INDSÆT I StudentInfo VÆRDIER (3, 'John', 23, 'Norge', 1, '923 *******'), (4, 'Mitch', 22, 'Houston', 3, '934 ** ***** ')
Produktion
Vælg * fra StudentInfo 1 | Dekan | 20 | Californien | 2 | 934 ******* 2 | SAM | 22 | Texas | 2 | 976 ******* 3 | John | 23 | Norge | 1 | 923 ******* 4 | Mitch | 22 | Houston | 3 | 934 *******
Som du kan se, ligner outputformatet ikke helt det før. Så hvordan ændrer du formatet på output i SQLite? Lad os formatere output, så vores resultater er lidt lettere at læse.
- Formatering
Du kan bruge .mode til at ændre outputtilstand. Ovenstående eksempel bruger .mode liste, der viser resultaterne som en liste. Du kan også bruge .hoveder erklæring for at specificere, om kolonneoverskrifter skal vises eller ej. Når du har foretaget ændringerne, kan du se indstillingen ved hjælp af .at vise kommando.
datatyper i mysql med eksempler
Eksempel
sqlite> .mode 'column' sqlite> .headers on sqlite> .show echo: off eqp: off explain: auto headers: on mode: column nullvalue: '' output: stdout colseparator: '|' rækkeseparator: 'n' statistik: fra bredde: filnavn: StudentDetails.db
Produktion
VÆLG * FRA StudentInfo ID NAVN ALDRE ADRESSE AFDELING TELEFON ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 Californien 2934 ******* 2 SAM 22 Texas 2996 ******* 3 John 23 Norge 1923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Vælg forespørgsel
I SQLite bruges Select-sætningenat hente data fra en tabel, som returnerer data i form af en resultattabel. Disse resultattabeller kaldes også resultat sæt. Ved hjælp af SQLite select-sætning kan vi udføre enkle beregninger eller flere udtryk baseret på vores krav.Vi har allerede brugt en SELECT-sætning tidligere, da vi indsatte data.
Syntaks
VÆLG [ALLE | DISTINCT] resultat [FROM table-list] [WHERE expr]
- DISTINCT - Når vi bruger et særskilt nøgleord i en udvalgt sætning, returnerer det kun forskellige rækker med data.
- ALLE - Hvis vi bruger ALLE nøgleord i en udvalgt sætning returnerer det alle datarækkerne, selvom det er duplikeret.
- FRA tabel-liste - Det er en liste over tabeller, hvorfra du vil hente data.
- HVOR udtryk - WHERE-udtrykket bruges til at definere vores brugerdefinerede betingelser for at hente de krævede data fra tabeller.
Eksempel 1
VÆLG ID, NAVN FRA StudentInfo HVOR ALDER<21
Produktion
ID-NAVN ---------- ---------- 1 Dekan
Eksempel 2
Vælg NAVN FRA StudentInfo WHERE DEPARTMENTID = (VÆLG DeptID FRA DepartmentInfo WHERE DeptName = 'Psychology')
Produktion
// henter folk fra afdeling, hvis id er 2 NAVN ---------- Dean SAM
- Forespørgsel om SQLite-opdatering
I SQLite kan UPDATE-sætningen bruges til at ændre de eksisterende poster i en tabel.WHERE-klausulen om SQLite kan bruges til at specificere nøjagtigt, hvilke rækker der skal opdateres. Du kan nemt opdatere alle rækker, nogle rækker eller ingen, afhængigt af filtreringsbetingelserne anvendt af WHERE-klausulen.
Syntaks
OPDATER tabelnavn SET kolonne1 = værdi1, kolonne2 = værdi2 ...., kolonneN = værdiN HVOR [betingelse]
Eksempel
OPDATER StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2'
Produktion
VÆLG * FRA StudentInfo ID NAVN ALDRE ADRESSE AFDELING TELEFON ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 Californien 2934 ******* 2 SAM 22 Texas 4976 ******* 3 John 23 Norge 1923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Slet forespørgsel
I SQLite kan DELETE-sætningen bruges til at slette posten fra tabellen. Du kan nemt slette alle rækker, nogle rækker eller ingen, afhængigt af filtreringsbetingelserne anvendt af WHERE-klausulen.
Eksempel
SLET FRA DepartmentInfo WHERE DeptName = 'Videnskab'
Produktion
VÆLG * FRA DepartmentInfo DeptID DeptName ---------- ----------- 1 Matematik 2 Psykologi 3 Sport 4 Musik
Hvis du forsøger at slette en post, der henvises til af en fremmed nøgle, får du en fejl. Du skal først slette de fremmede nøgleposter, før du sletter den primære nøgleregistrering. Lad os prøve at slette instituttets videnskab.
Eksempel
SLET FRA DepartmentInfo WHERE DeptName = 'Musik' Fejl: UDENLANDSK KEY-begrænsning mislykkedes
Så vi er nødt til at slette de udenlandske nøgleposter, før vi sletter den primære nøgle.
SLET FRA StudentInfo WHERE DEPARTMENTID = 4 sqlite> SLET FRA DepartmentInfo WHERE DeptName = 'Music' sqlite> VÆLG * FRA DepartmentInfo DeptID DeptName ---------- ----------- 1 Matematik 2 Psykologi 3 Sport VÆLG * FRA StudentInfo ID NAVN ALDER ADRESSE AFDELING TELEFON ---------- ---------- ---------- ------- --- ------------ ---------- 1 Dean 20 Californien 2934 ******* 3 John 23 Norge 1923 ****** * 4 Mitch 22 Houston 3934 *******
Nu ved du, hvordan du redigerer posterne i SQLite Database-tabellen. Når vi bevæger os længere i denne SQLite-selvstudieblog, lad os diskutere forskellige klausuler og betingelser, som du oftest støder på i SQLite.
SQLite-klausuler / betingelser
Før du kommer i gang med klausuler, er her den komplette syntaks for SELECT-sætningen i SQLite.
Syntaks
VÆLG [ALLE | DISTINCT] resultat [FRA tabel-liste] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compound-op select] * [ORDER BY sort-expr-list] [LIMIT heltal [(OFFSET |,) heltal ]]
Bemærk: Jeg har opdateret StudentInfo- og DepartmentInfo-tabellerne som vist nedenfor.
// Studenttabel-ID NAVN ALDRE ADRESSE AFDELING TELEFON ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 Californien 2934 ******* 3 John 23 Norge1923 ******* 4 Mitch 22 Houston 3934 ******* 2 SAM 22 Texas 4996 ******* 5 Johny 23 Norge 2945 ******* 6 Robin 23 Norge 2 Ukendt // Afdelingsoplysninger DeptID Afdelingsnavn - --------- ----------- 1 Matematik 2 Psykologi 3 Sport 4 Musik 5 Videnskab
- SQLite HVOR
I SQLite bruges WHERE-klausulen til at pålægge SELECT-sætningen begrænsninger ved at definere en eller flere betingelser for at hente de krævede data fra tabeller i databasen.Hvis den angivne betingelse er opfyldt eller sand, returnerer den specifik værdi fra tabellen. Som du har set før WHERE-klausulen bruges ikke kun i SELECT-sætningen, men den bruges også i UPDATE, SLET-sætning osv.
Eksempel
VÆLG NAVN FRA StudentInfo WHERE AGE = 23NAME ---------- John Johny Robin
I SQLite er der et antal relationelle operatører, der kan bruges med WHERE-klausulen.
- SQLite GROUP BY
I SQLite bruges GROUP BY-klausulen til at samle data i en enkelt række, hvor værdien af en eller flere specificerede kolonner gentages. Denne klausul bruges med WHERE-klausulen i SELECT-sætningen og går foran ORDER BY-klausulen.
Syntaks
VÆLG resultat FRA [tabel-liste] GROUP BY [expr-liste]
VÆLG NAVN, ADRESSE FRA StudentInfo GRUPPE VED NAVN NAVN ADRESSE ---------- ---------- Dekan Californien John Norge Johny Norge Mitch Houston Robin Norge SAM Texas
Bemærk, at grupperingsprocessen har to trin. Først bruges GROUP BY-udtrykket til at arrangere tabelrækker i forskellige grupper. Når grupperne er defineret, definerer SELECT-sætningen, hvordan disse grupper bliver fladt ned i en enkelt række.
- SQLite ORDER BY
Generelt gemmer SQLite-tabeller data i uspecificeret rækkefølge, og det returnerer poster i den samme uspecificerede rækkefølge, mens data hentes ved hjælp af SQLite select-sætning. I sådanne tilfælde kan du bruge ORDER BY-klausulen bruges til at sortere kolonneoptegnelser enten i stigende eller faldende rækkefølge. I eksemplet nedenfor har jeg grupperet og bestilt9 i faldende rækkefølge) dataene baseret på adressen.
Syntaks
VÆLG udtryk FRA tabeller-listen [HVOR betingelser] BESTIL EFTER kolonne1, kolonne2, ... [ASC | DESC]
Eksempel
VÆLG ADRESSE, TÆLLING (ADRESSE) FRA StudentInfo GRUPPE EFTER ADRESSE ORDRE EFTER ADRESSE BESKRIVELSE ADRESSETAL (ADRESSE) ---------- -------------- Texas 1 Norge 3 Houston 1 Californien 1
- SQLite HAR BY
I SQLite er AT HAVE klausul er identisk med HVOR klausul. HAVING-klausul er en yderligere betingelse, der anvendes efter sammenlægning finder sted sammen med gruppen ved i select statement. Generelt i SQLite, HVOR klausul bruges til at anvende en betingelse for individuelle elementer i en tabel ogdet AT HAVE klausul bruges til at tilføje filterbetingelser baseret på grupperne oprettet af gruppe efter klausul.
Eksempel
VÆLG ADRESSE, TÆLLING (ADRESSE) FRA StudentInfo GRUPPE EFTER ADRESSE, DER HAR TÆLLER (*)> 1 ADRESSETÆLLING (ADRESSE) ---------- -------------- Norge 3
- SQLite Limit-klausul
I SQLite bruges LIMIT-klausulen til at indstille en grænse for de poster, der returneres af select-sætningen. Lad os overveje et eksempel for at forstå konceptet.
Syntaks
VÆLG udtryk FRA tabeller-listen [WHERE betingelser] LIMIT antal rækker OFFSET offset_value
Eksempel
VÆLG NAVN, ADRESSE FRA StudentInfo GRÆNSE 4 OFFSET 2 NAVN ADRESSE ---------- ---------- Mitch Houston SAM Texas Johny Norge Robin Norge
OFFSETer valgfri, og den definerer, hvor mange rækker der skal springes over i starten af resultatsættet baseret på offset_value .
- SQLite OG & ELLER
I SQLite bruges AND & OR-operatørerne til at udføre flere betingelser for valg, indsættelse, opdatering og sletning af udsagn baseret på vores krav. SQLite AND-operatør returnerer rækker eller poster, der opfylder de betingelser, der er defineret ved hjælp af AND-operatoren.
Eksempel 1
VÆLG NAVN FRA StudentInfo HVOR ALDER = 22 OG ADRESSE = 'Texas' NAVN ---------- SAM
ELLER-betingelse bruges til at definere flere betingelser i SQLite-udsagn, og det returnerer rækker eller poster fra udsagn, hvis en af en betingelse er opfyldt.
Eksempel 2
VÆLG NAVN FRA StudentInfo HVOR (AGE = 22 OG ADRESSE = 'Norge') ELLER ADRESSE = 'Norge' NAVN ---------- John Johny Robin
- SQLite GLOB-operatør
I SQLite bruges GLOB-operatøren til at kontrollere, om den givne strengværdi matcher et bestemt mønster eller ej. Hvis strengværdien matcher mønsterværdien, vender den tilbage sand og det ligner LIKE-operatøren. GLOB er også store og små bogstaver
Syntaks
VÆLG * FRA tabelnavn HVOR kolonnenavn GLOB 'søgeekspression'
Eksempel
VÆLG * FRA StudentInfo HVOR NAVN GLOB 'Joh *' ID NAVN ALDRE ADRESSE AFDELING TELEFON ---------- ---------- ---------- --- ------- ------------ ---------- 3 Johannes 23 Norge 1923 ******* 5 Johny 23 Norge 2945 ** *****
- SQLite Distinct
I SQLite scanner DISTINCT-nøgleordet resultatsættet for SELECT-sætningen og eliminerer eventuelle dobbelte rækker. Også NULL-værdier betragtes som duplikater, så hvis vi bruger DISTINCT-klausulen med en kolonne, der har NULL-værdier, beholder den kun en række af en NULL-værdi. Når du anvender DISTINCT i flere kolonner, returnerer sætningen hver unikke kombination af coulnm1 og kolonne2.
Eksempel
VÆLG DISTINCT ALDER FRA StudentInfo ALDER ---------- 20 23 22
- SQLite IN-operatør
I SQLite bruges IN-operatøren til at bestemme, om den givne værdi svarer til en liste over givne værdier eller resultatet, der returneres af underforespørgslen.
Eksempel
VÆLG NAVN FRA StudentInfo HVOR ADRESSE I ('Texas', 'Houston') NAVN ---------- Mitch SAM- SQLite UNION & UNION ALL
I SQLite bruges UNION-operatøren til at kombinere resultatsæt af 2 eller flere SELECT-sætninger, og det fjerner duplikerede rækker mellem de forskellige SELECT-sætninger. Husk, at de SELECT-sætninger, som vi brugte med UNION-operatøren, skal have det samme antal felter i resultatsættene med lignende datatyper.
Syntaks
VÆLG expression1, expression2, ... expression_n FRA tabeller [WHERE betingelser] UNION / UNION ALLE VÆLG expression1, expression2, ... expression_n FRA tabeller [WHERE betingelser]
Eksempel
VÆLG AFDELINGID FRA StudentInfo UNION VÆLG AFDELING FRA Afdelingsinfo BESTIL AF DEPARTEMENTID ASC AFDELINGID ------------ 1 2 3 4 5
UNION ALL-operatoren bruges til at kombinere resultatsæt med 2 eller flere SELECT-sætninger, og den returnerer alle rækkerne inklusive duplikaterne.
Eksempel
VÆLG AFDELINGID FRA StudentInfo UNION ALLE VÆLG AFDELING FRA Afdelingsinfo BESTIL AF DEPARTEMENTID ASC AFDELINGID ------------ 1 1 2 2 2 2 3 3 4 4 5
Med dette har vi dækket de mest basale kommandoer, som du muligvis skal bruge, når du arbejder med SQLite. Gå videre med denne SQLite-tutorial, lad os tjekke sammenføjelseserklæringen i SQLite.
Tilslutter sig SQLite
I SQLite er Joinsbruges til at kombinere poster fra to eller flere tabeller i en database og få poster baseret på vores krav. Different type JOINS, der er tilgængelig i SQLite, er:
- Indre sammenføjning -INNER JOIN bruges til at kombinere og returnere kun matchende poster fra multipeltabeller baseret på betingelserne defineret i SQLite-sætninger.
- Ydre sammenføjning -SQLite Outer Join vælger matchende rækker fra flere tabeller, det samme som Indre sammenføjning og nogle andre rækker uden for forholdet.Enkelt sagt kan vi sige SQLiteYDRE MEDLEMer en tilføjelse afINDRE MEDLEM . Generelt har vi tre typer ydre sammenføjninger i SQL-standard, de er VENSTRE, HØJRE og FULLE Ydre sammenføjninger, men SQLite understøtter kun VENSTRE OUTER JOIN.
- Cross Join -Det bruges til at få det cartesianske produkt af rækkerved at matche hver række i den første tabel med hver række i den anden tabel.
- Selvdeltagelse - Detbruges til at slutte sig til den samme tabel med sig selv. For at bruge Self Join skal vi oprette forskellige aliasnavne til den samme tabel for at udføre operationer baseret på vores krav.
Konceptet svarer til andre relationelle databasesystemer som SQL. Så for at vide mere kan du henvise til denne artikel på .
Med dette har vi dækket de grundlæggende SQLite-kommandoer. Avancerede koncepter er ikke dækket her. Så hold øje med en anden artikel om avancerede SQLite-koncepter. Selv med alle de gode funktioner, som SQLite har at tilbyde, har det også visse ulemper.
SQLite-tutorial: Ulemper ved SQLite
Nedenfor er de ulemper, der er forbundet med at bruge SQLite:
- Det fungerer ikke godt i klient / serverarkitektur.
- En SQLite-databasestørrelse er i de fleste tilfælde begrænset til 2 GB.
- SQLite har ikke implementeret RIGHT OUTER JOIN og FULL YTRE JOIN. Med SQLite kan vi kun implementere LEFT OUTER JOIN.
- Visninger i SQLite er skrivebeskyttet. Vi kan ikke bruge DML-sætninger (Indsæt, Opdater og Slet) med Visninger.
- Vi kan ikke bruge GRANT- og REVOKE-udsagn med SQLite.
Med dette kommer vi til en ende på denne SQLite-tutorial.
Hvis du ønsker at lære mere om MySQL og lær denne open source relationsdatabase, og tjek derefter vores som kommer med instruktørstyret live træning og projektoplevelse i det virkelige liv. Denne træning hjælper dig med at forstå MySQL i dybden og hjælper dig med at opnå mestring over emnet.
Har du et spørgsmål til os? Nævn det i kommentarsektionen i denne SQLite-tutorial, og jeg vender tilbage til dig.