Funzione di rango in MySQL

155

Devo scoprire il grado di clienti. Qui sto aggiungendo la query SQL standard ANSI corrispondente per il mio requisito. Aiutatemi a convertirlo in MySQL.

SELECT RANK() OVER (PARTITION BY Gender ORDER BY Age) AS [Partition by Gender], 
  FirstName, 
  Age,
  Gender 
FROM Person

C'è qualche funzione per scoprire il grado in MySQL?

mysql  sql  rank 
— aadi
fonte

Risposte:

266

Un'opzione è utilizzare una variabile di classificazione, come la seguente:

SELECT    first_name,
          age,
          gender,
          @curRank := @curRank + 1 AS rank
FROM      person p, (SELECT @curRank := 0) r
ORDER BY  age;

La (SELECT @curRank := 0)parte consente l'inizializzazione della variabile senza richiedere un SETcomando separato .

Caso di prova:

CREATE TABLE person (id int, first_name varchar(20), age int, gender char(1));

INSERT INTO person VALUES (1, 'Bob', 25, 'M');
INSERT INTO person VALUES (2, 'Jane', 20, 'F');
INSERT INTO person VALUES (3, 'Jack', 30, 'M');
INSERT INTO person VALUES (4, 'Bill', 32, 'M');
INSERT INTO person VALUES (5, 'Nick', 22, 'M');
INSERT INTO person VALUES (6, 'Kathy', 18, 'F');
INSERT INTO person VALUES (7, 'Steve', 36, 'M');
INSERT INTO person VALUES (8, 'Anne', 25, 'F');

Risultato:

+------------+------+--------+------+
| first_name | age  | gender | rank |
+------------+------+--------+------+
| Kathy      |   18 | F      |    1 |
| Jane       |   20 | F      |    2 |
| Nick       |   22 | M      |    3 |
| Bob        |   25 | M      |    4 |
| Anne       |   25 | F      |    5 |
| Jack       |   30 | M      |    6 |
| Bill       |   32 | M      |    7 |
| Steve      |   36 | M      |    8 |
+------------+------+--------+------+
8 rows in set (0.02 sec)
— Daniel Vassallo
fonte
52
+1 per l'iniziale inizializzazione in linea, è un bel trucco.
— Charles,
28
Non ha chiesto una partizione però? La mia comprensione delle partizioni è che il set di risultati avrebbe classifiche separate per maschio e femmina.
— Jesse Dhillon,
2
@Jesse: In tal caso, di recente ho risposto a una domanda simile: stackoverflow.com/questions/3162389/multiple-ranks-in-one-table
— Daniel Vassallo,
6
E se volessi dare il grado 4 ad Anne e Bob entrambi?
— Fahim Parkar,
8
Questo non implementa l'esempio della domanda in quanto manca la partition by genderparte della funzione analitica (che "numera" il valore di rango per genere non per il risultato complessivo)
— a_horse_with_no_name
53

Ecco una soluzione generica che assegna il rango denso sulla partizione alle righe. Utilizza le variabili utente:

CREATE TABLE person (
    id INT NOT NULL PRIMARY KEY,
    firstname VARCHAR(10),
    gender VARCHAR(1),
    age INT
);

INSERT INTO person (id, firstname, gender, age) VALUES
(1,  'Adams',  'M', 33),
(2,  'Matt',   'M', 31),
(3,  'Grace',  'F', 25),
(4,  'Harry',  'M', 20),
(5,  'Scott',  'M', 30),
(6,  'Sarah',  'F', 30),
(7,  'Tony',   'M', 30),
(8,  'Lucy',   'F', 27),
(9,  'Zoe',    'F', 30),
(10, 'Megan',  'F', 26),
(11, 'Emily',  'F', 20),
(12, 'Peter',  'M', 20),
(13, 'John',   'M', 21),
(14, 'Kate',   'F', 35),
(15, 'James',  'M', 32),
(16, 'Cole',   'M', 25),
(17, 'Dennis', 'M', 27),
(18, 'Smith',  'M', 35),
(19, 'Zack',   'M', 35),
(20, 'Jill',   'F', 25);

SELECT person.*, @rank := CASE
    WHEN @partval = gender AND @rankval = age THEN @rank
    WHEN @partval = gender AND (@rankval := age) IS NOT NULL THEN @rank + 1
    WHEN (@partval := gender) IS NOT NULL AND (@rankval := age) IS NOT NULL THEN 1
END AS rnk
FROM person, (SELECT @rank := NULL, @partval := NULL, @rankval := NULL) AS x
ORDER BY gender, age;

Si noti che le assegnazioni delle variabili vengono inserite all'interno CASEdell'espressione. Questo (in teoria) si occupa del problema dell'ordine di valutazione. La IS NOT NULLsi aggiunge per gestire il tipo di dati di conversione e le questioni cortocircuiti.

PS: può essere facilmente convertito in un numero di riga sulla partizione rimuovendo tutte le condizioni che verificano il pareggio.

| id | firstname | gender | age | rank |
|----|-----------|--------|-----|------|
| 11 | Emily     | F      | 20  | 1    |
| 20 | Jill      | F      | 25  | 2    |
| 3  | Grace     | F      | 25  | 2    |
| 10 | Megan     | F      | 26  | 3    |
| 8  | Lucy      | F      | 27  | 4    |
| 6  | Sarah     | F      | 30  | 5    |
| 9  | Zoe       | F      | 30  | 5    |
| 14 | Kate      | F      | 35  | 6    |
| 4  | Harry     | M      | 20  | 1    |
| 12 | Peter     | M      | 20  | 1    |
| 13 | John      | M      | 21  | 2    |
| 16 | Cole      | M      | 25  | 3    |
| 17 | Dennis    | M      | 27  | 4    |
| 7  | Tony      | M      | 30  | 5    |
| 5  | Scott     | M      | 30  | 5    |
| 2  | Matt      | M      | 31  | 6    |
| 15 | James     | M      | 32  | 7    |
| 1  | Adams     | M      | 33  | 8    |
| 18 | Smith     | M      | 35  | 9    |
| 19 | Zack      | M      | 35  | 9    |

Demo su violino db <>

— Salman A
fonte
2
Questa soluzione, o la soluzione di Mukesh, dovrebbe essere la soluzione corretta. Anche se tecnicamente credo che entrambe le soluzioni per voi ragazzi rappresentiate una classifica densa e non una classifica regolare. Ecco una buona spiegazione delle differenze: sqlservercurry.com/2009/04/… .
— Modulitos,
Puoi anche farci sapere come dovrebbe essere esattamente il codice .php? Ho provato a seguire, ma il codice sopra non funziona. Come inserire in formato .php?
— creatore
Questa soluzione non è molto generica; non funzionerà se rank_column ha un valore di 0. sqlfiddle.com/#!2/9c5dd/1
— mike
1
@mike Aggiungi una sezione ELSE all'istruzione CASE:ELSE @rank_count := @rank_count + 1
— Prince Odame
1
@abhash ORDER BY gender, age DESC?
— Salman A
52

Mentre la risposta più votata si classifica, non si partiziona, puoi fare un self Join per ottenere anche tutto il partizionamento:

SELECT    a.first_name,
      a.age,
      a.gender,
        count(b.age)+1 as rank
FROM  person a left join person b on a.age>b.age and a.gender=b.gender 
group by  a.first_name,
      a.age,
      a.gender

Caso d'uso

CREATE TABLE person (id int, first_name varchar(20), age int, gender char(1));

INSERT INTO person VALUES (1, 'Bob', 25, 'M');
INSERT INTO person VALUES (2, 'Jane', 20, 'F');
INSERT INTO person VALUES (3, 'Jack', 30, 'M');
INSERT INTO person VALUES (4, 'Bill', 32, 'M');
INSERT INTO person VALUES (5, 'Nick', 22, 'M');
INSERT INTO person VALUES (6, 'Kathy', 18, 'F');
INSERT INTO person VALUES (7, 'Steve', 36, 'M');
INSERT INTO person VALUES (8, 'Anne', 25, 'F');

Risposta :

Bill    32  M   4
Bob     25  M   2
Jack    30  M   3
Nick    22  M   1
Steve   36  M   5
Anne    25  F   3
Jane    20  F   2
Kathy   18  F   1
— Rahul Agarwal
fonte
questa è una risposta meravigliosa proprio perché ho bisogno di fare una classifica delle partizioni. Grazie Signore!
— Kim impila il
IMO ha la stessa complessità di subselect nella risposta di @Sam Kidman: O (n ^ 2). Ma non so se è possibile farlo meglio in MySQL.
— xmedeko
Dai un'occhiata a onlamp.com/pub/a/mysql/2007/03/29/… per un ottimo tutorial sulla stessa linea
— ferics2
Unisciti a te stesso per ottenere il grado! È fantastico. Finalmente una soluzione senza variabili e senza funzioni della finestra di MySQL 8 . :)
— Timo,
24

Una modifica della versione di Daniel per calcolare il percentile insieme al grado. Anche due persone con gli stessi voti avranno lo stesso rango.

set @totalStudents = 0;
select count(*) into @totalStudents from marksheets;
SELECT id, score, @curRank := IF(@prevVal=score, @curRank, @studentNumber) AS rank, 
@percentile := IF(@prevVal=score, @percentile, (@totalStudents - @studentNumber + 1)/(@totalStudents)*100),
@studentNumber := @studentNumber + 1 as studentNumber, 
@prevVal:=score
FROM marksheets, (
SELECT @curRank :=0, @prevVal:=null, @studentNumber:=1, @percentile:=100
) r
ORDER BY score DESC

Risultati della query per dati di esempio - 

+----+-------+------+---------------+---------------+-----------------+
| id | score | rank | percentile    | studentNumber | @prevVal:=score |
+----+-------+------+---------------+---------------+-----------------+
| 10 |    98 |    1 | 100.000000000 |             2 |              98 |
|  5 |    95 |    2 |  90.000000000 |             3 |              95 |
|  6 |    91 |    3 |  80.000000000 |             4 |              91 |
|  2 |    91 |    3 |  80.000000000 |             5 |              91 |
|  8 |    90 |    5 |  60.000000000 |             6 |              90 |
|  1 |    90 |    5 |  60.000000000 |             7 |              90 |
|  9 |    84 |    7 |  40.000000000 |             8 |              84 |
|  3 |    83 |    8 |  30.000000000 |             9 |              83 |
|  4 |    72 |    9 |  20.000000000 |            10 |              72 |
|  7 |    60 |   10 |  10.000000000 |            11 |              60 |
+----+-------+------+---------------+---------------+-----------------+
— Mukesh Soni
fonte
1
Anche se questo non è davvero ottimale in termini di prestazioni, è fantastico!
— Gaspa79,
18

Combinazione della risposta di Daniel e Salman. Tuttavia, il grado non darà poiché continua la sequenza con i legami. Invece salta il grado al successivo. Quindi il massimo raggiunge sempre il conteggio delle righe.

    SELECT    first_name,
              age,
              gender,
              IF(age=@_last_age,@curRank:=@curRank,@curRank:=@_sequence) AS rank,
              @_sequence:=@_sequence+1,@_last_age:=age
    FROM      person p, (SELECT @curRank := 1, @_sequence:=1, @_last_age:=0) r
    ORDER BY  age;

Schema e test case:

CREATE TABLE person (id int, first_name varchar(20), age int, gender char(1));

INSERT INTO person VALUES (1, 'Bob', 25, 'M');
INSERT INTO person VALUES (2, 'Jane', 20, 'F');
INSERT INTO person VALUES (3, 'Jack', 30, 'M');
INSERT INTO person VALUES (4, 'Bill', 32, 'M');
INSERT INTO person VALUES (5, 'Nick', 22, 'M');
INSERT INTO person VALUES (6, 'Kathy', 18, 'F');
INSERT INTO person VALUES (7, 'Steve', 36, 'M');
INSERT INTO person VALUES (8, 'Anne', 25, 'F');
INSERT INTO person VALUES (9, 'Kamal', 25, 'M');
INSERT INTO person VALUES (10, 'Saman', 32, 'M');

Produzione:

+------------+------+--------+------+--------------------------+-----------------+
| first_name | age  | gender | rank | @_sequence:=@_sequence+1 | @_last_age:=age |
+------------+------+--------+------+--------------------------+-----------------+
| Kathy      |   18 | F      |    1 |                        2 |              18 |
| Jane       |   20 | F      |    2 |                        3 |              20 |
| Nick       |   22 | M      |    3 |                        4 |              22 |
| Kamal      |   25 | M      |    4 |                        5 |              25 |
| Anne       |   25 | F      |    4 |                        6 |              25 |
| Bob        |   25 | M      |    4 |                        7 |              25 |
| Jack       |   30 | M      |    7 |                        8 |              30 |
| Bill       |   32 | M      |    8 |                        9 |              32 |
| Saman      |   32 | M      |    8 |                       10 |              32 |
| Steve      |   36 | M      |   10 |                       11 |              36 |
+------------+------+--------+------+--------------------------+-----------------+
— erandac
fonte
1
Sono nuovo di MySQL ma questa soluzione è ok? Nei documenti MySQL afferma che "l'ordine di valutazione per le espressioni che coinvolgono le variabili utente non è definito". dev.mysql.com/doc/refman/5.7/en/user-variables.html
— narduk
13

A partire da MySQL 8, puoi finalmente utilizzare le funzioni della finestra anche in MySQL: https://dev.mysql.com/doc/refman/8.0/en/window-functions.html

La tua query può essere scritta esattamente allo stesso modo:

SELECT RANK() OVER (PARTITION BY Gender ORDER BY Age) AS `Partition by Gender`, 
  FirstName, 
  Age,
  Gender 
FROM Person
— Lukas Eder
fonte
Non è sbagliato, semplicemente non funziona con le versioni precedenti di SQL. inoltre era una specie di copia e passato della sua domanda, quindi non sembra che si adatti alla risposta.
— newdark-it
4
@ brand-it Per quelli di MySQL 8+, questa risposta è importante poiché ci consente di sapere che Rank è ora disponibile. Se non avessi scorrere fino a questo punto, suppongo che le risposte precedenti fossero l'unica soluzione.
— Steve Smith,
1
@SteveSmith Un buon punto è bello avere questa risposta per coloro che usano la versione più recente di MYSQL.
— newdark-it
Sì, sono scoraggiato da molte risposte con le variabili utente e i blocchi logici. Una nuova versione di MySQL consente di farlo MOLTO semplice con la funzione RANK () che offre un raggruppamento integrato per partizioni.
— James Bond il
5

@Sam, il tuo punto è eccellente in termini concettuali, ma penso che tu abbia frainteso quello che dicono i documenti di MySQL nella pagina di riferimento - o ho frainteso :-) - e volevo solo aggiungere questo in modo che se qualcuno si sente a disagio con il @ La risposta di Daniel sarà più rassicurata o almeno scavare un po 'più a fondo.

Vedi l' "@curRank := @curRank + 1 AS rank"interno SELECTnon è una "dichiarazione", è una parte "atomica" della dichiarazione, quindi dovrebbe essere sicuro.

Il documento a cui fai riferimento continua a mostrare esempi in cui la stessa variabile definita dall'utente in 2 parti (atomiche) dell'istruzione, ad esempio "SELECT @curRank, @curRank := @curRank + 1 AS rank".

Si potrebbe obiettare che @curRankviene usato due volte nella risposta di @ Daniel: (1) the "@curRank := @curRank + 1 AS rank"e (2) the "(SELECT @curRank := 0) r"ma poiché il secondo utilizzo fa parte delFROM clausola, sono abbastanza sicuro che sia garantito per primo; essenzialmente trasformandolo in una seconda e precedente affermazione.

In effetti, nella stessa pagina di documenti MySQL a cui hai fatto riferimento, vedrai la stessa soluzione nei commenti: potrebbe essere da dove l'ha presa @Daniel; Sì, lo so che sono i commenti, ma sono i commenti sulla pagina dei documenti ufficiali e questo ha un certo peso.

— David Husnian
fonte
Niente di tutto ciò è giustificato dalla documentazione. È solo una speculazione (sfocata). Come tutte le risposte, entrambe usano e scrivono la stessa variabile, che il manuale dice non è esplicitamente definito, sebbene il manuale abbia un sacco di testo inutile su cosa potrebbe funzionare come ti aspetti, senza dire cosa pensa che ti aspetti o che uso una descrizione del comportamento non garantito è. PS A partire da 8.0 l'assegnazione delle variabili al di fuori di SET è obsoleta.
— Philipxy,
4

La soluzione più semplice per determinare il rango di un dato valore è contare il numero di valori prima di esso. Supponiamo di avere i seguenti valori:

10 20 30 30 30 40
  • Tutti i 30valori sono considerati terzi
  • Tutti i 40valori sono considerati 6 ° (rango) o 4 ° (rango denso)

Ora torniamo alla domanda originale. Ecco alcuni dati di esempio che vengono ordinati come descritto in OP (i ranghi previsti vengono aggiunti a destra):

+------+-----------+------+--------+    +------+------------+
| id   | firstname | age  | gender |    | rank | dense_rank |
+------+-----------+------+--------+    +------+------------+
|   11 | Emily     |   20 | F      |    |    1 |          1 |
|    3 | Grace     |   25 | F      |    |    2 |          2 |
|   20 | Jill      |   25 | F      |    |    2 |          2 |
|   10 | Megan     |   26 | F      |    |    4 |          3 |
|    8 | Lucy      |   27 | F      |    |    5 |          4 |
|    6 | Sarah     |   30 | F      |    |    6 |          5 |
|    9 | Zoe       |   30 | F      |    |    6 |          5 |
|   14 | Kate      |   35 | F      |    |    8 |          6 |
|    4 | Harry     |   20 | M      |    |    1 |          1 |
|   12 | Peter     |   20 | M      |    |    1 |          1 |
|   13 | John      |   21 | M      |    |    3 |          2 |
|   16 | Cole      |   25 | M      |    |    4 |          3 |
|   17 | Dennis    |   27 | M      |    |    5 |          4 |
|    5 | Scott     |   30 | M      |    |    6 |          5 |
|    7 | Tony      |   30 | M      |    |    6 |          5 |
|    2 | Matt      |   31 | M      |    |    8 |          6 |
|   15 | James     |   32 | M      |    |    9 |          7 |
|    1 | Adams     |   33 | M      |    |   10 |          8 |
|   18 | Smith     |   35 | M      |    |   11 |          9 |
|   19 | Zack      |   35 | M      |    |   11 |          9 |
+------+-----------+------+--------+    +------+------------+

Per calcolare RANK() OVER (PARTITION BY Gender ORDER BY Age)per Sarah , puoi utilizzare questa query:

SELECT COUNT(id) + 1 AS rank, COUNT(DISTINCT age) + 1 AS dense_rank
FROM testdata
WHERE gender = (SELECT gender FROM testdata WHERE id = 6)
AND age < (SELECT age FROM testdata WHERE id = 6)

+------+------------+
| rank | dense_rank |
+------+------------+
|    6 |          5 |
+------+------------+

Per calcolare RANK() OVER (PARTITION BY Gender ORDER BY Age)per Tutte le righe è possibile utilizzare questa query:

SELECT testdata.id, COUNT(lesser.id) + 1 AS rank, COUNT(DISTINCT lesser.age) + 1 AS dense_rank
FROM testdata
LEFT JOIN testdata AS lesser ON lesser.age < testdata.age AND lesser.gender = testdata.gender
GROUP BY testdata.id

Ed ecco il risultato (i valori uniti vengono aggiunti a destra):

+------+------+------------+    +-----------+-----+--------+
| id   | rank | dense_rank |    | firstname | age | gender |
+------+------+------------+    +-----------+-----+--------+
|   11 |    1 |          1 |    | Emily     |  20 | F      |
|    3 |    2 |          2 |    | Grace     |  25 | F      |
|   20 |    2 |          2 |    | Jill      |  25 | F      |
|   10 |    4 |          3 |    | Megan     |  26 | F      |
|    8 |    5 |          4 |    | Lucy      |  27 | F      |
|    6 |    6 |          5 |    | Sarah     |  30 | F      |
|    9 |    6 |          5 |    | Zoe       |  30 | F      |
|   14 |    8 |          6 |    | Kate      |  35 | F      |
|    4 |    1 |          1 |    | Harry     |  20 | M      |
|   12 |    1 |          1 |    | Peter     |  20 | M      |
|   13 |    3 |          2 |    | John      |  21 | M      |
|   16 |    4 |          3 |    | Cole      |  25 | M      |
|   17 |    5 |          4 |    | Dennis    |  27 | M      |
|    5 |    6 |          5 |    | Scott     |  30 | M      |
|    7 |    6 |          5 |    | Tony      |  30 | M      |
|    2 |    8 |          6 |    | Matt      |  31 | M      |
|   15 |    9 |          7 |    | James     |  32 | M      |
|    1 |   10 |          8 |    | Adams     |  33 | M      |
|   18 |   11 |          9 |    | Smith     |  35 | M      |
|   19 |   11 |          9 |    | Zack      |  35 | M      |
+------+------+------------+    +-----------+-----+--------+
— Salman A
fonte
3

Se vuoi classificare solo una persona puoi fare quanto segue:

SELECT COUNT(Age) + 1
 FROM PERSON
WHERE(Age < age_to_rank)

Questa classifica corrisponde alla funzione RANK dell'oracolo (dove se hai persone della stessa età ottengono la stessa classifica e la classifica successiva non è consecutiva).

È un po 'più veloce rispetto all'utilizzo di una delle soluzioni di cui sopra in una sottoquery e la selezione da quella per ottenere il ranking di una persona.

Questo può essere usato per classificare tutti ma è più lento delle soluzioni di cui sopra. 

SELECT
  Age AS age_var,
(
  SELECT COUNT(Age) + 1
  FROM Person
  WHERE (Age < age_var)
 ) AS rank
 FROM Person
— Sam Kidman
fonte
Può aumentare molto più lentamente delle soluzioni precedenti quando Personaumenta il numero di righe nella tabella. È O (n ^ 2) vs O (n) più lento.
— xmedeko
2

Per evitare il " comunque " nella risposta di Erandac in combinazione con le risposte di Daniel e Salman, si può usare una delle seguenti "soluzioni alternative"

SELECT customerID, myDate

  -- partition ranking works only with CTE / from MySQL 8.0 on
  , RANK() OVER (PARTITION BY customerID ORDER BY dateFrom) AS rank, 

  -- Erandac's method in combination of Daniel's and Salman's
  -- count all items in sequence, maximum reaches row count.
  , IF(customerID=@_lastRank, @_curRank:=@_curRank, @_curRank:=@_sequence+1) AS sequenceRank
  , @_sequence:=@_sequence+1 as sequenceOverAll

  -- Dense partition ranking, works also with MySQL 5.7
  -- remember to set offset values in from clause
  , IF(customerID=@_lastRank, @_nxtRank:=@_nxtRank, @_nxtRank:=@_nxtRank+1 ) AS partitionRank
  , IF(customerID=@_lastRank, @_overPart:=@_overPart+1, @_overPart:=1 ) AS partitionSequence

  , @_lastRank:=customerID
FROM myCustomers, 
  (SELECT @_curRank:=0, @_sequence:=0, @_lastRank:=0, @_nxtRank:=0, @_overPart:=0 ) r
ORDER BY customerID, myDate

La classifica delle partizioni nella terza variante in questo frammento di codice restituirà numeri di classifica continui. questo porterà a una struttura di dati simile al rank() over partition byrisultato. Ad esempio, vedi sotto. In particolare, partitionSequence inizierà sempre con 1 per ogni nuovo partitionRank , usando questo metodo:

customerID    myDate   sequenceRank (Erandac)
                          |    sequenceOverAll
                          |     |   partitionRank
                          |     |     | partitionSequence
                          |     |     |    | lastRank
... lines ommitted for clarity
40    09.11.2016 11:19    1     44    1   44    40
40    09.12.2016 12:08    1     45    1   45    40
40    09.12.2016 12:08    1     46    1   46    40
40    09.12.2016 12:11    1     47    1   47    40
40    09.12.2016 12:12    1     48    1   48    40
40    13.10.2017 16:31    1     49    1   49    40
40    15.10.2017 11:00    1     50    1   50    40
76    01.07.2015 00:24    51    51    2    1    76
77    04.08.2014 13:35    52    52    3    1    77
79    15.04.2015 20:25    53    53    4    1    79
79    24.04.2018 11:44    53    54    4    2    79
79    08.10.2018 17:37    53    55    4    3    79
117   09.07.2014 18:21    56    56    5    1   117
119   26.06.2014 13:55    57    57    6    1   119
119   02.03.2015 10:23    57    58    6    2   119
119   12.10.2015 10:16    57    59    6    3   119
119   08.04.2016 09:32    57    60    6    4   119
119   05.10.2016 12:41    57    61    6    5   119
119   05.10.2016 12:42    57    62    6    6   119
...
— Max
fonte
0 
select id,first_name,gender,age,
rank() over(partition by gender order by age) rank_g
from person

CREATE TABLE person (id int, first_name varchar(20), age int, gender char(1));

INSERT INTO person VALUES (1, 'Bob', 25, 'M');
INSERT INTO person VALUES (2, 'Jane', 20, 'F');
INSERT INTO person VALUES (3, 'Jack', 30, 'M');
INSERT INTO person VALUES (4, 'Bill', 32, 'M');
INSERT INTO person VALUES (5, 'Nick', 22, 'M');
INSERT INTO person VALUES (6, 'Kathy', 18, 'F');
INSERT INTO person VALUES (7, 'Steve', 36, 'M');
INSERT INTO person VALUES (8, 'Anne', 25, 'F');
INSERT INTO person VALUES (9,'AKSH',32,'M');
— Aditya
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.