Dichiarazioni dei casi SQLite

SQLite ha un'istruzione Case che ci consente di includere la logica condizionale nelle nostre dichiarazioni SQL. Le espressioni del caso SQLite eseguono un elenco di condizioni e restituiscono un'espressione basata sui risultati. Le dichiarazioni dei casi SQLite si comportano in modo identico a if - allora - else dichiarazioni come le altre lingue di scripting. Se la frase è valida, possiamo utilizzare l'istruzione Case SQLite all'interno di una qualsiasi delle clausole o delle istruzioni SQL. In generale, l'istruzione Case SQLite inizia con un'espressione opzionale e una o più quando ... allora clausole, una clausola altrimenti facoltativa e una parola chiave finale necessaria.

Sintassi dell'istruzione Caso in SQLite:

In SQLite, l'istruzione del caso di solito ha una delle due forme.

SQLite Simple Case Dichiarazione:

Caso test_statement
Quando [condizione1] quindi [istruzione1]
Quando [condizione2] quindi [istruzione2]
..
..
..
Quando [condizione (n)] quindi [istruzione (n)]
Else [Dichiarazione]
FINE

Usiamo la sintassi sopra per stabilire molte condizioni per raggiungere il risultato desiderato. Quando e poi le clausole vengono utilizzate nella sintassi sopra. Funzionano in un ordine logico. Per restituire l'output finale, questo metodo confronta ogni istruzione con l'elenco delle dichiarazioni. Questo è un approccio abbastanza semplice per l'esecuzione della dichiarazione del caso in base ai requisiti dell'utente. Ogni condizione e affermazione sono interdipendenti, il che significa, quando la prima condizione è vera, l'affermazione viene eseguita solo dopo. In questo modo vengono eseguite tutte le condizioni e le dichiarazioni. Se una condizione è falsa, il controllo viene trasferito nella parte altro come mostrato nella sintassi sopra.

Per scegliere il risultato, l'istruzione Case Query valuta un elenco di dichiarazioni. Vale la pena notare che la semplice espressione del caso cerca solo l'equità. Considerando che, l'istruzione del caso guardato può utilizzare qualsiasi forma di ispezione.

Dichiarazione del caso di ricerca SQLite:

Caso test_statement
Quando [Boolean Dichiarazione1] allora [Dichiarazione1]
Quando [Boolean Dichiarazione2] allora [Dichiarazione2]
Else [dichiarazione] fine

Se l'istruzione booleana nel raggruppamento specificato è valida, l'istruzione del caso di ricerca la valuta e restituisce il risultato corrispondente. Quando non viene rilevata alcuna istruzione valida, l'istruzione Case Query restituisce l'istruzione nella condizione altro. Se la clausola else viene trascurata, l'istruzione del caso guardato restituisce null. Quando i criteri dichiarati sono soddisfatti, l'istruzione del caso di ricerca termina la valutazione e l'esecuzione.

Creazione di tabella per l'istruzione Case in SQLite:

Innanzitutto, abbiamo creato un tavolo e dato il nome "Studente" con la query Crea. La tabella è impostata con le diverse colonne come ID con il tipo di dati intero e crea ID come chiave primaria, nome ed e -mail è impostata con il testo del tipo di dati. L'ultima colonna CGPA viene assegnato un tipo di dati di testo. Lo studente della tabella e i suoi attributi sono mostrati nella shell SQLite come segue:

Crea uno studente di tavolo (
...> id int primario chiave ,
...> Testo del nome ,
...> Testo e -mail ,
…> Float cgpa
...>);

Ora, dobbiamo inserire i valori contro ogni colonna dello studente della tabella. Con la query di inserto SQLite, abbiamo inserito cinque righe in ciascuna delle colonne specificate nello studente della tabella. Lo screenshot seguente mostra il modo di inserire i record nelle colonne della tabella.

sqlite> inserisci nei valori degli studenti (2, 'ibrahim', '[email protected] ', 3.20);
sqlite> inserisci nei valori degli studenti (3, "maha", "[email protected] ', 3.9);
SQLite> Insert in Student Values ​​(4, 'Jennifer', '[email protected] ', 2.5);
sqlite> inserisci nei valori degli studenti (5, 'rehan', '[email protected] ', 3.10);

Visingiamo se i dati vengono registrati nello studente della tabella. Utilizzando l'istruzione SELECT, abbiamo recuperato gli interi dati nello studente della tabella in un formato della tabella. La dichiarazione di cui sopra è rappresentata nello screenshot seguente:

sqlite> seleziona * da studente;

Esempio 1: Programma di utilizzo di SQLite Simple Case Dichiarazione:

Abbiamo utilizzato una semplice istruzione Case con l'istruzione SELECT per mostrare il funzionamento dell'istruzione Case in SQLite.

Qui, abbiamo utilizzato un'istruzione selezionata e selezionato un ID, nome e CGPA della colonna dallo studente della tabella. Successivamente, abbiamo usato una dichiarazione del caso che confronta il CGPA dello studente. Corrisponde al CGPA con la condizione se il CGPA è maggiore o uguale a 4.00 o no. In tal caso, allora dà a quel cgpa un a+. Ma se la condizione è falsa, il caso passerà all'istruzione successiva e verificherà se il CGPA è maggiore di 3.5. Se la condizione è vera, allora assegna a questo CGPA un grado "A".

In questo modo, il controllo viene passato a ciascuna dichiarazione del caso fino a quando il CGPA non soddisfa la condizione data. Se tutti i casi sono falsi, allora la clausola Else verrà eseguita e stamperà un'istruzione fallita.

SQLite> Seleziona ID, nome, CGPA,
...> Caso
...> Quando cgpa> = 4.00 Quindi "A+"
...> Quando cgpa> = 3.5 Quindi "A"
...> Quando cgpa> = 3.0 Quindi "B"
...> Quando cgpa> = 2.5 Quindi "C"
...> altrimenti "fallisci"
...> fine come "grado"
...> dallo studente;

Ora eseguiremo la domanda e esamineremo il risultato. Dovrebbe apparire così: la colonna di grado è inclusa nello studente della tabella insieme ai valori dell'istruzione del caso.

Esempio 2: Programma di utilizzo dell'istruzione Caso di ricerca SQLite:

Per determinare il risultato, l'istruzione del caso cercato analizza un insieme di espressioni. L'espressione del caso semplice si confronta semplicemente per l'uguaglianza. Considerando che l'espressione del caso di ricerca può confrontare in alcun modo.

Una dichiarazione del caso booleano viene utilizzata nell'esempio fornito. Per questo, abbiamo una query selezionata attraverso la quale abbiamo selezionato tre attributi ID, nome e CGPA dallo studente della tabella. Solo questi attributi e i loro valori corrispondenti appariranno come output. Quindi, abbiamo una parola chiave Case per l'istruzione Caso SQLite. La condizione viene applicata con la parola chiave quando. Innanzitutto, i controlli del caso se il CGPA è maggiore di 3.5 e poi assegna il grado A. Se la condizione non è soddisfatta qui, allora passeremo alla nostra seconda dichiarazione del caso che controlla la condizione se è soddisfatta qui o no. Se entrambi i nostri casi sono falsi, allora la parte altro eseguirà e stampa il grado C.

SQLite> Seleziona ID, nome, CGPA,
...> Caso
...> Quando CGPA> 3.5 Quindi "A"
...> Quando CGPA> 3.0 e CGPA < 2.5 THEN "B"
...> altrimenti
...> "C"
...> fine "grado"
...> dallo studente;

Quando si eseguono la query del caso sopra, i risultati sono ottenuti in questo modo:

Conclusione:

Abbiamo studiato la sintassi di base delle dichiarazioni dei casi in questo articolo. Abbiamo anche visto una varietà di istanze di dichiarazione dei casi. Sono state anche insegnate le regole per le dichiarazioni dei casi. Abbiamo imparato usando la dichiarazione del caso SQLite in questo post e quando farlo.