SELECT – Recuperare le informazioni

SELECT – Recuperare le informazioni

Ora che le nostre tabelle sono state create e riempite di dati, vediamo come si possono reperire i nostri dati precedentemente memorizzati. Vedremo infatti quale sia l'enunciato SQL che ci consente di estrarre i dati dalle nostre tabelle e di presentarli, in maniera generica, specifica o come meglio preferite. Per esempio è possibile mostrare l'intero contenuto di una tabella:
SELECT * FROM nome_tabella;

Oppure potremmo selezionare un'informazione che si riduce a una singola colonna di una sola riga:
SELECT nome_colonna FROM nome_tabella WHERE nome_colonna_xy='valore_stringa';

Nel caso specifico della nostra tabella attori si avrà per esempio:
Select Attore from attori WHERE Attore='Andy Garcia';

+-------------+
| Attore      |
+-------------+
| Andy Garcia |
+-------------+
1 row in set (0.00 sec)

La dichiarazione di SELECT ha diverse clausole (o parti), che potete combinare al bisogno per recuperare le informazioni alle quali siete interessati. Ognuna di queste clausole può chiaramente essere più o meno semplice o complessa e quindi l'enunciato SELECT nella sua interezza può essere a sua volta semplice o complesso. Cercheremo quindi di non utilizzare query (l'uso di SELECT per l'appunto) che richiedano ore soltanto per capirne il significato, questo perchè ci annoierebbe ed inoltre sarebbe poco costruttivo. La sintassi ufficiale di SELECT è la seguente:
Nmysql - h select
Name: 'SELECT'
Description:
Syntax:
SELECT
[ALL | DISTINCT | DISTINCTROW ]
[HIGH_PRIORITY]
[STRAIGHT_JOIN]
[SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
select_expr, ...
[FROM table_references
[WHERE where_condition]
[GROUP BY {col_name | expr | position}
[ASC | DESC], ... [WITH ROLLUP]]
[HAVING where_condition]
[ORDER BY {col_name | expr | position}
[ASC | DESC], ...]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]
[PROCEDURE procedure_name(argument_list)]
[INTO OUTFILE 'file_name' export_options
| INTO DUMPFILE 'file_name'
| INTO var_name [, var_name]]
[FOR UPDATE | LOCK IN SHARE MODE]]

SELECT is used to retrieve rows selected from one or more tables, and
can include UNION statements and subqueries. See [HELP UNION], and
http://dev.mysql.com/doc/refman/5.0/en/subqueries.html.

The most commonly used clauses of SELECT statements are these:

  • Each select_expr indicates a column that you want to retrieve. There must be at least one select_expr.
  • table_references indicates the table or tables from which to retrieve rows. Its syntax is described in [HELP JOIN].
  • The WHERE clause, if given, indicates the condition or conditions that rows must satisfy to be selected. where_condition is an expression that evaluates to true for each row to be selected. The statement selects all rows if there is no WHERE clause.

In the WHERE clause, you can use any of the functions and operators that MySQL supports, except for aggregate (summary) functions. See [HELP =].

SELECT can also be used to retrieve rows computed without reference to any table.

URL: http://dev.mysql.com/doc/refman/5.0/en/select.html

Riassumendo si potrebbe semplificare nel seguente modo:
SELECT quello che volete selezionare
FROM tabella o tabelle o query
WHERE condizioni che devono essere soddisfatte
ORDER BY eventuali metodi di ordinamento;

Per scrivere un enunciato SELECT, indicate cosa volete recuperare e nel caso, aggiungete alcune clausole opzionali. Le clausole che abbiamo mostrato nell'esempio (FROM e WHERE) sono le più comuni, anche se ne possono essere specificate altre come ad esempio GROUP BY, ORDER BY, e LIMIT.
Ricordate che SQL è un linguaggio privo di formattazione, quindi quando scrivete le vostre query con SELECT, non siete costretti ad inserire delle interruzioni di linea negli stessi punti che vedete negli esempi qui riportati.
A proposito di visualizzazione dei dati di input si possono avere le seguenti forme:

show fields from attori;
+--------+--------------+------+-----+---------+----------------
| Field  | Type         | Null | Key | Default | Extra
+--------+--------------+------+-----+---------+----------------
| id     | int(11)      | NO   | PRI | NULL    | auto_increment
| Attore | varchar(255) | NO   | UNI | NULL    |
| foto   | longblob     | YES  |     | NULL    |
+--------+--------------+------+-----+---------+----------------
3 rows in set (0.00 sec)

show fields from attoriG
*************************** 1. row ***************************
    Field: id
    Type: int(11)
     Null: NO
     Key: PRI
Default: NULL
   Extra: auto_increment
*************************** 2. row ***************************
  Field: Attore
   Type: varchar(255)
   Null: NO
    Key: UNI
Default: NULL
  Extra:
*************************** 3. row ***************************
  Field: foto
   Type: longblob
   Null: YES
    Key:
Default: NULL
  Extra:
3 rows in set (0.00 sec)

select id, Attore from attori ORDER BY Attore LIMIT 10;
+-----+------------------+
| id  | Attore           |
+-----+------------------+
|  65 | Adrienne Corri   |
|   1 | Al Pacino        |
|   2 | Andy Garcia      |
|  55 | Anna Magnani     |
|  43 | Annette Bening   |
|  59 | Anthony Quinn    |
|   4 | Antonio Banderas |
|   3 | Ariella Reggio   |
| 143 | Atossa Leoni     |
| 111 | Ben Kingsley     |
+-----+------------------+
10 rows in set (0.00 sec)

select id, Attore from attori ORDER BY Attore LIMIT 10G
*************************** 1. row ***************************
    id: 65
Attore: Adrienne Corri
*************************** 2. row ***************************
    id: 1
Attore: Al Pacino
*************************** 3. row ***************************
    id: 2
Attore: Andy Garcia
*************************** 4. row ***************************
    id: 55
Attore: Anna Magnani
*************************** 5. row ***************************
    id: 43
Attore: Annette Bening
*************************** 6. row ***************************
    id: 59
Attore: Anthony Quinn
*************************** 7. row ***************************
    id: 4
Attore: Antonio Banderas
*************************** 8. row ***************************
    id: 3
Attore: Ariella Reggio
*************************** 9. row ***************************
    id: 143
Attore: Atossa Leoni
*************************** 10. row ***************************
    id: 111
Attore: Ben Kingsley
10 rows in set (0.00 sec)

Si noti che utilizzando il carattere G a fine istruzione e sostituendolo con il solito terminatore ; i risultati ottenuti vengono visualizzati in orizzontale anziché nella classica visualizzazione verticale. Questa sarà l'unica formattazione consentita dal monitor. La clausola FROM di solito è presente in una query, ma non è strettamente necessaria se non dovete indicare alcuna tabella. Per esempio, la seguente query mostra semplicemente i valori di alcune espressioni che possono essere calcolate senza riferimento ad alcuna tabella:

SELECT 2+2 as Somma, 'Hello world!' as Stringa,VERSION();
+-------+--------------+---------------------+
| Somma | Stringa      | VERSION()           |
+-------+--------------+---------------------+
|     4 | Hello world! | 5.0.67-community-nt |
+-------+--------------+---------------------+
1 row in set (0.00 sec)

Quando invece usate una clausola FROM per indicare una tabella dalla quale recuperare i dati, indicate anche quali colonne si desidera siano visualizzate. La forma più "generica" di SELECT usa * come identificatore di colonna, con il significato di "tutte le colonne". Le colonne sono mostrate nell'ordine in cui MySQL le ha registrate nella tabella selezionata ed è lo stesso ordine evidenziato dalle clausole SHOW e DESCRIBE.
Per esempio si avrà che:

CREATE TABLE `student` (
`name` varchar(150) NOT NULL,
`sex` enum('F','M') NOT NULL,
`student_id` int(10) unsigned NOT NULL auto_increment,
PRIMARY KEY  (`student_id`)
) ENGINE=InnoDB;

INSERT INTO `student` (`name`,`sex`,`student_id`) VALUES
('Megan','F',1),
('Josef','M',2),
('Kyle','M',3),
('Katie','F',4);

show fields from student;
+------------+------------------+------+-----+---------+----------------+
| Field      | Type             | Null | Key | Default | Extra          |
+------------+------------------+------+-----+---------+----------------+
| name       | varchar(150)     | NO   |     | NULL    |                |
| sex        | enum('F','M')    | NO   |     | NULL    |                |
| student_id | int(10) unsigned | NO   | PRI | NULL    | auto_increment |
+------------+------------------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

describe student;
+------------+------------------+------+-----+---------+----------------+
| Field      | Type             | Null | Key | Default | Extra          |
+------------+------------------+------+-----+---------+----------------+
| name       | varchar(150)     | NO   |     | NULL    |                |
| sex        | enum('F','M')    | NO   |     | NULL    |                |
| student_id | int(10) unsigned | NO   | PRI | NULL    | auto_increment |
+------------+------------------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

select * from student;
+-------+-----+------------+
| name  | sex | student_id |
+-------+-----+------------+
| Megan | F   |          1 |
| Josef | M   |          2 |
| Kyle  | M   |          3 |
| Katie | F   |          4 |
+-------+-----+------------+
4 rows in set (0.00 sec)

Quindi si può facilmente indicare in modo esplicito il nome della colonna o delle colonne che si desidera vedere; se specificate più di una colonna, separate i nomi utilizzando le virgole e definendo sequenzialmente l'ordine delle colonne nel modo che più vi aggrada.

Indicare i criteri di selezione
Per restringere l'insieme delle registrazioni recuperate tramite un'enunciato SELECT su deve utilizzare la clausola WHERE che specifichi i criteri di selezione delle righe (record) da estrarre.

Per esempio, utilizzando la tabella di prova student sopra citata, si avrà che:

select * from student where student_id = 3;
+------+-----+------------+
| name | sex | student_id |
+------+-----+------------+
| Kyle | M   |          3 |
+------+-----+------------+
1 row in set (0.00 sec)

select * from student where name = 'KYLE';
+------+-----+------------+
| name | sex | student_id |
+------+-----+------------+
| Kyle | M   |          3 |
+------+-----+------------+
1 row in set (0.00 sec)

Notare che le comparazioni fra stringhe di solito non sono sensibili alla differenza fra maiuscole e minuscole.
Le espressioni all'interno delle clausole where possono utilizzare gli operatori aritmetici, di uguglianza e logici. Si possono utilizzare altresì le parantesi per poter raggruppare parti di un'espressione.

Operatori aritmetici

Operatori relazionali

Operatori logici

Costruiamo quindi un nuovo database di prova con una tabella contenente alcuni dati relativi ai presidenti degli Stati Uniti nel modo seguente:
Dati di prova

Quando formulate un'interrogazione che richiede l'uso di operatori logici fate attenzione a non confondere il significato dell'operatore logico AND con l'uso quotidiano della congiunzione "e", omofono nella lingua naturale inglese dell'AND logico. Supponiamo di voler trovare "i presidenti nati in Virginia e i presidenti nati in Massachusetts". La domanda viene posta utilizzando la congiunzione "e", che sembra implicare una query del seguente tipo:

mysql- select last_name,first_name, state from president
    - WHERE (state='VA') AND (state='MA');
Empty set (0.00 sec)

E' chiaro dalla mancanza di risultati che l'interrogazione non è stata posta in maniera corretta. Ma per quale ragione?
Perchè in realtà il suo significato è "seleziona i presidenti che sono nati sia in Virginia sia in Massachusetts", il che non ha senso!
In italiano possiamo anche usare "e", ma in SQL dobbiamo mettere in relazione le due condizioni utilizzando OR, ottenendo così:

mysql- select last_name,first_name, state from president
     - WHERE (state='VA') OR (state='MA');
+------------+-------------+-------+
| last_name  | first_name  | state |
+------------+-------------+-------+
| Washington | George      | VA    |
| Adams      | John        | MA    |
| Jefferson  | Thomas      | VA    |
| Madison    | James       | VA    |
| Monroe     | James       | VA    |
| Adams      | John Quincy | MA    |
| Harrison   | William H.  | VA    |
| Tyler      | John        | VA    |
| Taylor     | Zachary     | VA    |
| Wilson     | Woodrow     | VA    |
| Kennedy    | John F      | MA    |
| Bush       | George H.W. | MA    |
+------------+-------------+-------+
12 rows in set (0.00 sec)

Post successivo

Posted in Documentazione Tecnica, MySQL and tagged , .