{{ message }}
Repository navigation
Expand file tree
/
Copy pathSQL CHEAT SHEET.SQL
More file actions
667 lines (562 loc) · 19.6 KB
/
Copy pathSQL CHEAT SHEET.SQL
File metadata and controls
667 lines (562 loc) · 19.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
/*# SQL Basics Cheat Sheet
O Resumo de Conceitos Básicos de SQL fornece a sintaxe de todas as cláusulas básicas, demonstra como escrever diferentes condições e inclui exemplos.
-- O que é SQL?:
Structured Query Language, ou SQL, é a linguagem declarativa de consulta padrão para manipulação de dados mantidos em sistemas de gerenciamento de banco de dados relacional (RDBMS) ou para processamento de fluxo em um sistema de gerenciamento de fluxo de dados relacional (RDSMS). Foi desenvolvido pela primeira vez na década de 1970 pela IBM.
Embora todas as linguagens SQL compartilhem uma estrutura básica, alguns comandos e estilos específicos podem diferir ligeiramente. Dialectos populares incluem MySQL, SQLite, SQL Server, Oracle SQL, entre outros. O PostgreSQL é um bom ponto de partida, pois está próximo da sintaxe SQL padrão e pode ser facilmente adaptado para outros dialetos.
-- COMPONENTES
SQL consiste em vários componentes, cada um servindo a seu propósito exclusivo na comunicação do banco de dados:
Queries(Consultas):
Este é o componente que permite recuperar dados de um banco de dados. A instrução SELECT é mais comumente usada para esse propósito.
Data Definition Language (DDL):
Linguagem de definição de dados (DDL) permite criar, alterar ou excluir bancos de dados e seus objetos relacionados, como tabelas, visualizações, etc. Os comandos incluem CREATE, ALTER, DROP e TRUNCATE.
Data Manipulation Language (DML):
Linguagem de manipulação de dados (DML) permite gerenciar dados dentro de objetos de banco de dados. Esses comandos incluem SELECT, INSERT, UPDATE e DELETE.
Data Control Language (DCL):
Linguagem de controle de dados (DCL), inclui comandos como GRANT e REVOKE, que tratam principalmente de direitos, permissões e outras tarefas de gerenciamento de nível de controle para o sistema de banco de dados.
*/
-- COUNTRY e CITY
Tabela COUNTRY (País)
| id | name | population | area |
| :---: | :---: | :---: | :---: |
| 1 | Italia | 66600000 | 640000 |
| 2 | Brazil | 21400000 | 851000000 |
| 3 | Estados Unidads | 331900000 | 331893745 |
| 4 | Argentina | 36260130 | 2780400 |
| ... | ... | ... | ... |
Tabela CITY (Cidade)
| id | name | country_id | population | rating |
| :---: | :---: | :---: | :---: | :---: |
| 1 | Florença | 1 | 22400000 | 3 |
| 2 | Fortaleza | 2 | 26800000 | 5 |
| 3 | São Paulo | 2 | 12300000 | 1 |
| 4 | Maranhão | 2 | 685000000 | 33 |
| ... | ... | ... | ... | ... |
-- QUERIES (Consultas):
Consultar todas(`*`) as colunas da tabela `COUNTRY`:
SELECT *
FROM country
Resultado:
| id | name | population | area |
| :---: | :---: | :---: | :---: |
| 1 | Italia | 66600000 | 640000 |
| 2 | Brazil | 21400000 | 851000000 |
| 3 | Estados Unidads | 331900000 | 331893745 |
| 4 | Argentina | 36260130 | 2780400 |
Consultar as colunas `ID` e NAME da tabela -- CITY:
SELECT id, name
FROM city
Resultado:
| id | name |
| :---: | :---: |
| 1 | Florença |
| 2 | Fortaleza |
| 3 | São Paulo |
| 4 | Maranhão |
| ... | ... |
Consultar os -- NAME das -- CITY classificados pela coluna -- RATING na ordem Crescente (ASC):
SELECT name, rating
FROM city
ORDER BY rating [ASC]
Resultado:
| name | rating |
| :---: | :---: |
| São Paulo | 1 |
| Florença | 3 |
| Fortaleza| 5 |
| Maranhão | 33 |
Consultar os -- NAME das -- CITY classificados pela coluna -- RATING na ordem Decrescente (DESC):
SELECT name, rating
FROM city
ORDER BY rating DESC
Resultado:
| name | rating |
| :---: | :---: |
| Maranhão | 33 |
| Fortaleza | 5 |
| Florença| 3 |
| São Paulo | 1 |
-- APELIDOS (ALIASES)
--# Exemplo em Colunas
Um alias ou apelido é um nome alternativo que pode ser atribuído a uma tabela ou a uma coluna em uma consulta. Isso pode ser útil para simplificar a consulta, melhorar a legibilidade do código ou evitar conflitos de nome.
Exemplo de consulta utilizando alias na coluna NAME da tabela CITY, com o apelido (AS) CITY_NAME:
```sql
SELECT name AS city_name
FROM city
Neste exemplo, em vez de retornar a coluna "name" com o nome original, a consulta retorna a mesma coluna com o apelido "city_name". Esse apelido pode ser usado para se referir à coluna em outras partes da consulta, como em cláusulas WHERE ou em outras junções.
Resultado:
| id | city_name |
| :---: | :---: |
| 4 | Maranhão |
| 3 | São Paulo |
| 2 | Fortaleza |
| 1 | Florença |
| ... | ... |
--# Exemplo em Tabela
Outra forma de utilizar aliases é atribuir apelidos às tabelas em uma consulta.
Exemplo de consulta utilizando alias nas tabelas CITY e COUNTRY, com os apelidos CI e CO, respectivamente:
SELECT co.name, ci.name
FROM city AS ci
JOIN country AS co
ON ci.country_id = co.id
Neste exemplo, as tabelas CITY e COUNTRY foram apelidadas de CI e CO, respectivamente. Isso permite referenciar as tabelas de forma mais concisa na consulta. A junção é realizada comparando os valores das colunas COUNTRY_ID da tabela CI (apelido para CITY) e ID da tabela CO (apelido para COUNTRY).
Resultado:
| id | name | population | area |
| :---: | :---: | :---: | :---: |
| 1 | Italia | 66600000 | 640000 |
| 2 | Brazil | 21400000 | 851000000 |
| id | name | country_id | population | rating |
| :---: | :---: | :---: | :---: | :---: |
| 1 | Florença | 1 | 22400000 | 3 |
| 2 | Fortaleza | 2 | 26800000 | 5 |
| 3 | São Paulo | 2 | 12300000 | 1 |
| 4 | Maranhão | 2 | 685000000 | 33 |
_OBS: JOIN (ou explicitamente INNER JOIN) retorna linhas que possuem valores correspondentes em ambas as tabelas._
-- SUBCONSULTAS (SUBQUERIES)
Uma subconsulta é uma consulta aninhada dentro de outra consulta ou dentro de outra subconsulta. Existem diferentes tipos de subconsultas.
--# SINGLE VALUE
A subconsulta mais simples retorna exatamente uma coluna e exatamente uma linha. Pode ser usado com operadores de comparação =, <, <=, > ou >=.
Esta consulta encontra cidades com a mesma classificação de Paris:
SELECT name
FROM city
WHERE rating = (
SELECT rating
FROM city
WHERE name = 'Paris'
)
--# MULTIPLE VALUES
Uma subconsulta também pode retornar várias colunas ou várias linhas. Essas subconsultas podem ser usadas com os operadores IN, EXISTS, ALL ou ANY.
Esta consulta encontra cidades em países com população acima de 20 milhões:
SELECT name
FROM city
WHERE country_id IN (
SELECT country_id
FROM country
WHERE population > 20000000
)
--# CORRELATED
Uma subconsulta correlacionada refere-se às tabelas introduzidas na consulta externa. Uma subconsulta correlacionada depende da consulta externa. Ele não pode ser executado independentemente da consulta externa.
Esta consulta encontra cidades com uma população maior que a população média do país:
SELECT *
FROM city main_city
WHERE population > (
SELECT AVG(population)
FROM city average_city
WHERE average_city.country_id = main_city.country_id
)
Esta consulta encontra países que possuem pelo menos uma cidade:
SELECT name
FROM country
WHERE EXISTS (
SELECT *
FROM city
WHERE country_id = country.id
)
--# OPERADORES DE COMPARAÇÃO (COMPARISON OPERATORS)
a) Consultar -- NAME da -- CITY com -- RATING acima de 3
```sql
SELECT name
FROM city
WHERE rating > 3
Resultado:
| name |
| :---: |
| Fortaleza |
| Maranhão |
b) Consultar -- NAME de CITY diferente de `FLORENÇA` e `FORTALEZA`
```sql
SELECT name
FROM city
WHERE name != 'Florença'
AND name != 'Fortaleza'
Resultado:
| name |
| :---: |
| São Paulo |
| Maranhão |
--# OPERADORES DE TEXTO (TEXT OPERATORS)
a) Consultar -- NAME de CITY que começam com 'f' ou terminam com 'a':
SELECT name
FROM city
WHERE name LIKE 'f%'
OR name LIKE '%a'
Resultado:
| id | name |
| :---: | :---: |
| 1 | Florença |
| 2 | Fortaleza |
b) Consultar -- NAME de CITY que começe com qualquer letra seguida por 'ortaleza':
SELECT name
FROM city
WHERE name LIKE '_ortaleza'
Resultado:
| id | name |
| :---: | :---: |
| 2 | Fortaleza |
--# OUTROS OPERADORES (OTHER OPERATORS)
a) Consultar -- NAME de CITY com `POPULATION` entre(between) 500K e 5M:
SELECT name
FROM city
WHERE population BETWEEN 500000 AND 5000000
b) Consultar -- NAME de CITY que não possuem um valor de RATING:
SELECT name
FROM city
WHERE rating IS NOT NULL
c) Consultar -- NAME de CITY que estão em `COUNTRY` com `IDs` 1, 4, 7 ou 8:
SELECT name
FROM city
WHERE country_id IN (1, 4, 7, 8)
-- GERENCIANDO TABELAS (MANAGING TABLES)
Aqui estão algumas dicas para usar no SQL com uma tabela chamada DISTRICT, uma visualização representada por V e uma coluna representada por C:
a) Criar uma nova tabela chamada DISTRICT com três colunas (id, name, price):
```sql
CREATE TABLE district (id INT PRIMARY KEY, name VARCHAR NOT NULL,price INT DEFAULT 0)
```
Resultado após criar a tabela DISTRICT (Bairro):
| id | name | price |
| :---: | :---: | :---: |
OBS: Os valores para id, name e price devem ser inseridos nas respectivas colunas da tabela.
b) Para adicionar uma nova coluna chamada `WEALTH` à tabela -- DISTRICT, você pode usar a seguinte consulta:
```sql
ALTER TABLE district ADD COLUMN wealth
```
Resultado:
| id | name | price | wealth |
| :---: | :---: | :---: | :---: |
c) Para inserir os dados na tabela -- DISTRICT, você pode usar a seguinte consulta:
A nova linha foi adicionada à tabela district com o id igual a 1, o name igual a "Fortaleza", o price igual a 2000000 e o wealth igual a 4000000000.
```sql
INSERT INTO district (name, price, wealth) VALUES ('Fortaleza', 2000000, 4000000000)
Resultado:
| id | name | price | wealth |
| :---: | :---: | :---: | :---: |
| 1 | Fortaleza | 2000000 | 4000000000 |
d) Excluir coluna `WEALTH` da tabela -- DISTRICT
```sql
ALTER TABLE district DROP COLUMN wealth
```
Resultado:
| id | name | price |
| :---: | :---: | :---: |
| 1 | Fortaleza | 2000000 |
Adicionar uma restrição(`CONSTRAINT`)
```sql
ALTER TABLE district ADD constraint
```
OBS: As restrições(CONSTRAINT) podem ser especificadas quando a tabela é criada com a instrução CREATE TABLE ou depois que a tabela é criada com a instrução ALTER TABLE.
Excluir uma restrição(CONSTRAINT)
```sql
ALTER TABLE district DROP constraint
```
Renomear tabela "district1" para "T2"
```sql
ALTER TABLE district1 REMANE TO t2
```
Renomear Coluna "C1" para "C2" da tabela "district1"
```sql
ALTER TABLE district1 RENANE cl TO c2
```
Remover todos os dados da tabela -- DISTRICT
```sql
TRUNCATE TABLE district
```
Excluir a tabela -- DISTRICT do banco de dados
```sql
DROP TABLE district
```
-- GERENCIANDO GATILHOS(MANAGING TRIGGERS)
Criar ou modificar um gatilho(TRIGGER), neste exemplo o gatilho terá o nome de trigger_name
```sql
CREATE OR MODIFY TRIGGER trigger_name
WHEN EVENT
ON table_nane TRIGGER TYPE
EXECUTE stored_procedure
WHEN
- BEFORE -invocar(invoke) antes(BEFORE) que o evento ocorra
- AFTER -invocar(invoke) despois(AFTER) do evento ocorrer
EVENT
- INSERT - invoke for INSERT
- UPDATE - invoke for UPDATE
- DELETE - invoke for DELETE
TRIGGER_TYPE
- FOR EACH ROW
- FOR EACH STATEMENT
Crie um gatilho(TRIGGER) invocado antes que uma nova linha seja inserida na person table
```sql
CREATE TRIGGER
BEFORE INSERT
ON person FOR EACH ROW
EXECUTE stored_procedure
Excluir um gatilho(TRIGGER) específico
```sql
DROP TRIGGER trigger_name
```
-- GERENCIANDO VIEWS(MANAGING VIEWS)
Crie uma nova VIEW que consiste em cl e c2
```sql
CREATE VIEW v(c1,c2) AS
SELECT cl, c2
FROM district
```
Crie uma nova VIEW com a opção de verificação
```sql
CREATE VIEW v(c1,c2) AS
SELECT Cl, C2
FROM district
```
Criar uma VIEW recursiva
```sql
WITH [CASCADED | LOCAL] CHECK OPTION
CREATE RECURSIVE VIEW v AS
select-statement —- anchor part
UNION [ALL]
select-statement —- recursive part
```
Criar uma VIEW temporária
```sql
CREATE TEMPORARY VIEW v AS
SELECT cl, C2
FROM district
```
Excluir uma VIEW
```sql
DROP VIEW view_name
```
-- MODIFICANDO DADOS (MODIFYING DATA)
Inserir(INSERT) uma linha(ROW) na tabela(TABLE) -- DISTRICT
```sql
INSERT INTO district(column_list)
VALUES( value_list)
Inserir várias linhas(ROWS) na tabela(TABLE) -- DISTRICT:
INSERT INTO district(column_list)
VALUES (vatue_list),
(vatue_list), ....
Inserir linhas(ROWS) da tabela(TABLE) `district2` no -- district1:
INSERT INTO district1(column_list)
SELECT column_list
FROM district2
Update new value in the column cl for all rows
```sql
UPDATE district
SET cl = new_value
Update values in the column cl, c2 that match the condition
```sql
UPDATE district
SET cI = new_value,
c2 = new_value
WHERE condition
Delete all data in a table
```sql
DELETE FROM district
Delete subset of rows in a table
```sql
DELETE FROM district
WHERE condition
-- CONSULTANDO EM MÚLTIPLAS TABELAS (QUERYING FROM MULTIPLE TABLES)
Tabela COUNTRY (País)
| id | name |
| :---: | :---: |
| 1 | Italia |
| 2 | Brazil |
| 3 | Estados Unidads |
| 4 | Argentina |
| ... | ... |
Tabela CITY (Cidade)
| id | name | country_id |
| :---: | :---: | :---: |
| 1 | Florença | 1 |
| 2 | Fortaleza | 2 |
| 3 | São Paulo | 2 |
| 4 | Maranhão | 2 |
| ... | ... | ... |
--# INNER JOIN
JOIN (ou explicitamente INNER JOIN) retorna apenas as linhas das tabelas que têm correspondência na outra tabela. Em outras palavras, somente os registros que possuem valores correspondentes em ambas as tabelas são incluídos no resultado.
```sql
SELECT city.name, country.name
FROM city
[INNER] JOIN country
ON city.country_id = country.id
Resultado:
| city.name | country.name |
| :---: | :---: |
| Florença | Italia |
| Fortaleza | Brazil |
| São Paulo | Brazil |
| Maranhão | Brazil |
| ... | ... |
--# LEFT JOIN
LEFT JOIN retorna todas as linhas da tabela esquerda com linhas correspondentes da tabela à direita. Se não houver linha correspondente, NULLs são retornados como valores do segunda mesa.
```sql
SELECT city.name, country.name
FROM city
LEFT JOIN country
ON city.country_id = country.id
--# RIGHT JOIN
RIGHT JOIN retorna todas as linhas da tabela da direita com linhas correspondentes da tabela à esquerda. Se não houver linha correspondente, NULLs são retornados como valores da esquerda tabela.
```sql
SELECT city.name, country.name
FROM city
RIGHT JOIN country
ON city.country_id = country.id
--# FULL JOIN
FULL JOIN (ou explicitamente FULL OUTER JOIN) retorna todas as linhas de ambas as tabelas, incluindo registros que não têm correspondência na outra tabela. Quando um registro não possui correspondência na outra tabela, o valor para essa tabela é nulo. Em outras palavras, o resultado inclui todos os registros de ambas as tabelas, independentemente de haver correspondência ou não.
```sql
SELECT city.name, country.name
FROM city
FULL [OUTER] JOIN country
ON city.country_id = country.id
--# CROSS JOIN
CROSS JOIN retorna o produto cartesiano de duas tabelas. Em outras palavras, ele combina cada linha da primeira tabela com todas as linhas da segunda tabela, sem levar em consideração qualquer condição de junção. Existem duas sintaxes disponíveis.
```sql
SELECT city.name, country.name
FROM city
CROSS JOIN country
```sql
SELECT city.name, country.name
FROM city, country
--# NATURAL JOIN
NATURAL JOIN combina duas tabelas usando todas as colunas com o mesmo nome automaticamente, sem precisar especificar as condições de junção explicitamente. Em outras palavras, o NATURAL JOIN compara as colunas de ambas as tabelas com o mesmo nome e retorna as linhas que têm valores iguais nessas colunas.
```sql
SELECT city.name, country.name
FROM city
NATURAL JOIN country
-- FUNÇÕES AGREGADAS (AGGREGATE FUNCTIONS)
Funções agregadas SQL são funções integradas usadas para realizar alguns cálculos nos dados e retornar um único valor. É por isso que eles formam a base para “consultas agregadas”. Essas funções operam em um conjunto de linhas e retornam um único resultado resumido.
- count(column_name) − Conta o número de linhas de uma coluna.
```sql
SELECT COUNT(column_name)
FROM table_name
WHERE condition
- sum(column_name) − Retorna a soma de uma coluna numérica.
```sql
SELECT SUM(column_name)
FROM table_name
WHERE condition
- avg(column_name) − Retorna o valor médio de uma coluna numérica.
```sql
SELECT AVG(column_name)
FROM table_name
WHERE condition
- min(column_name) − Retorna o menor valor da coluna selecionada.
```sql
SELECT MIN(column_name)
FROM table_name
WHERE condition
- max(column_name) − Retorna o maior valor da coluna selecionada.
```sql
SELECT MAX(column_name)
FROM table_name
WHERE condition
Veja alguns exemplo de uso:
Descubra o número de cidades:
SELECT COUNT(rating)
FROM city
Descubra o número de cidades com classificações não nulas:
SELECT COUNT(DISTINCT country_id)
FROM city
Descubra o número de valores de país distintos:
SELECT MIN(population), MAX(population)
FROM country
Descubra as menores e as maiores populações do país:
SELECT country_id, SUM(population)
FROM city
GROUP BY country_id
Descubra a população total das cidades nos respectivos países:
SELECT country_id, AVG(rating)
FROM city
GROUP BY country_id
HAVING AVG(rating) > 3.0
-- AGRUPAMENTO (GROUPING)
--# GROUP BY
GROUP BY agrupa linhas que possuem os mesmos valores em colunas especificadas.
Ele calcula resumos (agregados) para cada combinação exclusiva de valores.
---- CITY (Cidade)
| id | name | country_id |
| :---: | :---: | :---: |
| 1 | Florença | 1 |
| 2 | Fortaleza | 2 |
| 3 | São Paulo | 2 |
| 4 | Maranhão | 2 |
| 5 | Lyon | 3 |
| 6 | Berlin | 1 |
| 7 | Warsaw | 3 |
| ... | ... | ... |
Agrupo todos os valores da coluna -- country_id agrupados em uma coluna chamada -- count.
```sql
SELECT country_id, COUNT(*) AS count
FROM city
GROUP BY country_id
Resultado:
| country_id | count |
| :---: | :---: |
| 1 | 2 |
| 2 | 3 |
| 3 | 2 |
| ... | ... |
-- USANDO RESTRIÇÕES SQL (USING SQL CONSTRAINTS)
Definir C1 e CZ como chave-primária(primary-key)
```sql
CREATE TABLE t(
cl INT, C2 INT, C3 VARCHAR,
PRIMARY KEY (cl,c2)
)
Defina a coluna c2 como uma chave-estrangeira(foreign-key)
```sql
CREATE TABLE district1(
Cl INT PRIMARY KEY,
C2 INT,
FOREIGN KEY (c2) REFERENCES t2(c2)
)
Torne os valores em cl e c2 exclusivos(UNIQUE)
```sql
CREATE TABLE t(
cl INT, cl INT,
UNIQUE(c2, c3)
)
Certifique-se de que cl > 0 e valores em cl>=c2
```sql
CREATE TABLE t(
cl INT, c2 INT,
CHECK(c1> 0 AND cl >= c2)
)
Definir valores na coluna c2 não é nulo (NOT NULL)
```sql
CREATE TABLE t(
cl INT PRIMARY KEY,
c2 VARCHAR NOT NULL
)
-- USANDO OPERADORES SQL (USING SQL OPERATORS)
Combine Rows FROM districtwo Queries
```sql
SELECT cl, C2 FROM districtl
UNION [ALL]
SELECT Cl, C2 FROM district2
Return The Intersection Of TWO Queries
```sql
SELECT cl, c2 FROM districdistrict1
INTERSECT
SELECT Cl, C2 FROM district2
Subtract A Result Set From Another Result Set
```sql
SELECT cl, c2 FROM districtl
MINUS
SELECT cl, C2 FROM district2
Query Rows Using Pattern Matching _
```sql
SELECT cl, c2 FROM districtl
WHERE Cl [NOT] LIKE pattern
Query Rows In A List
```sql
SELECT Cl, c2 FROM district
WHERE cl [NOT] IN value_list
Query Rows Between Two Values
```sql
SELECT cl, c2 FROM district
WHERE cl BETWEEN low AND high
Check If Values In A Table IS NULL Or Not
```sql
SELECT cl, C2 FROM district
WHERE cl IS [NOT] NULL
-- Referência
- [W3Schools - SQL Tutorial](https://www.w3schools.com/sql)
- [SQL Basics Cheat Sheet - LearnSQL.com](https://learnsql.com/blog/sql-basics-cheat-sheet/)
- [SQL Basics Cheat Sheet - DataCamp](https://www.datacamp.com/cheat-sheet/sql-basics-cheat-sheet)
You can’t perform that action at this time.