Bruke mysql boolsk datatype

Som standard tilbyr MySQL ikke en innfødt boolsk datatype. Imidlertid gir det oss Tinyint-datatypen, slik at vi kan lagre boolske verdier-lignende verdier med Tinyint-typen.

Denne guiden vil fokusere på hvordan du bruker MySQL Tinyint -datatypen for å lagre boolske verdier.

Grunnleggende bruk

MySQL definerer en verdi på 0 som falsk og en ikke-null verdi som sann. Derfor, for å bruke boolske bokstavelige verdier, bruker du konstantene sanne og usant som evaluerer verdien 0 og 1.

Et eksempel:

Velg sant, falsk;

Når du har utført spørringen ovenfor, vil du få en utgang som ligner den som er vist nedenfor:

mysql> velg sann, falsk;
+------+-------+
| Sant | Falsk |
+------+-------+
| 1 | 0 |
+------+-------+
1 rad i sett (0.00 sek)

Fra det ovennevnte kan vi utlede at MySQL anser henholdsvis 1 og 0 som sant og usant, henholdsvis.

Det er bra å merke seg at som store eller små bokstaver tilordner MySQL True and False 0 og 1 som vist i spørringen nedenfor:

Velg sann, falsk, sann, falsk, sann, falsk;

Utgangen er som vist nedenfor:

+------+-------+------+-------+------+-------+
| Sant | Falsk | sant | falsk | Sant | Falsk |
+------+-------+------+-------+------+-------+
| 1 | 0 | 1 | 0 | 1 | 0 |
+------+-------+------+-------+------+-------+
1 rad i sett (0.00 sek)

Eksempel Bruk saker

La oss bruke et eksempel for å illustrere hvordan vi kan bruke den boolske typen i MySQL.

Begynn med å lage en database og en tabell som heter språk, som vil lagre informasjon om forskjellige programmeringsspråk.

Inne i tabellen har vi følgende kolonner:

1. Id - int ikke null auto_increment
2. Language_name - varchar (100) ikke null
3. BEGINNER_FRENT - Boolean

Tenk på spørringen nedenfor for å implementere databasen ovenfor:

Opprette database prøvetatt;
Bruk prøvetatt;
Lag bordspråk (
Id int ikke null auto_increment,
Språknavn varchar (100),
BEGINNER_FRIVLY BOOLEAN,
Primærnøkkel (ID)
);

Når du har utført spørringen ovenfor, vil du ha den samplede databasen med språktabellen.

For å få informasjonen om tabellen over, kan vi bruke MySQL DESC -setningen som vist i utgangen nedenfor:

mysql> desc språk;
+-------------------+--------------+------+-----+---------+----------------+
| Felt | Type | Null | Nøkkel | Standard | Ekstra |
+-------------------+--------------+------+-----+---------+----------------+
| Id | int | Nei | Pri | Null | auto_increment |
| Språknavn | Varchar (100) | Ja | | Null | |
| BEGINNER_FRENTLY | Tinyint (1) | Ja | | Null | |
+-------------------+--------------+------+-----+---------+----------------+
3 rader i settet (0.01 sek)

Hvis du ser på det nybegynner -vennlige feltet, som vi setter som boolsk når du oppretter bordet, viser det nå type Tinyint.

I neste trinn, la oss legge til noen data i tabellen ved å bruke spørsmålene nedenfor:

Sett inn i prøvetaket.Språk (id, språknavn, nybegynner_vennlige) verdier (1, "python", true);
Sett inn i prøvetaket.Språk (id, språknavn, nybegynner_vennlige) verdier (2, "c ++", falsk);

Hvis du nå velger verdiene i tabellen ovenfor:

mysql> velg * fra samplet.språk
->;
+----+---------------+-------------------+
| Id | Språknavn | BEGINNER_FRENTLY |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
+----+---------------+-------------------+
2 rader i settet (0.00 sek)

Du vil se at verdiene er satt til henholdsvis 0 og 1.

MERK: Du kan lagre numeriske verdier i den boolske kolonnen annet enn sanne og falske verdier. Tenk for eksempel på spørringen nedenfor:

Sett inn i prøvetaket.Språk (id, språknavn, nybegynner_vennlige) verdier (3, "go lang", 10);

Hvis du utfører spørringen ovenfor, vil MySQL ikke rapportere en feil. I stedet vil den lagre den numeriske verdien som 10. Tenk på utgangen som er vist nedenfor:

mysql> velg * fra samplet.språk;
+----+---------------+-------------------+
| Id | Språknavn | BEGINNER_FRENTLY |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 2 | C ++ | 0 |
| 3 | Gå lang | 10 |
+----+---------------+-------------------+
3 rader i settet (0.00 sek)

Mysql boolean operatører

MySQL støtter forskjellige boolske operatører som er sant, er usant, er ikke sant og er ikke falsk. Basert på navnet kan du bestemme at noen gjør nøyaktig det samme.

Er for eksempel sant og er ikke usant er lik. Det samme tilfellet gjelder for det andre paret.

Vi kan imidlertid bruke disse operatørene til å få et sett med verdier som er sanne eller usanne. For eksempel får spørringen nedenfor alle verdiene der nybegynner er sant.

mysql> velg * fra samplet.Språk der nybegynner_vennlige er sant;
+----+---------------+-------------------+
| Id | Språknavn | BEGINNER_FRENTLY |
+----+---------------+-------------------+
| 1 | Python | 1 |
| 3 | Gå lang | 10 |
+----+---------------+-------------------+
2 rader i settet (0.00 sek)

Som vi kan se fra utdataene, får vi bare verdier der verdien av nybegynner_vennlige er sann.

Du kan også få de falske verdiene ved hjelp av noen av dem Er sant eller er ikke sant.

mysql> velg * fra samplet.Språk der nybegynner_vennlige ikke er sant;
+----+---------------+-------------------+
| Id | Språknavn | BEGINNER_FRENTLY |
+----+---------------+-------------------+
| 2 | C ++ | 0 |
+----+---------------+-------------------+
1 rad i sett (0.00 sek)

Konklusjon

Denne guiden har vist deg hvordan du implementerer og bruker MySQL Boolean Data -typer for å lagre sanne eller falske verdier.