Diretório de artigos
- Comandos básicos de operação de banco de dados
-
- Regras de nomenclatura
- Operações da biblioteca
- Operações de tabela
- Registrar operações na tabela
- Chave primária e incremento automático
- DQL (consulta de dados)
- Mecanismo de armazenamento (compreensão)
- ver (compreender)
- Importação e exportação de dados de banco de dados (comandos DBA)
- Transação
- índice
- Três especificações principais de design para bancos de dados (conteúdo principal, frequentemente questionado em entrevistas)
- Ordem de execução SQL
- Funções comuns
-
-
- função inferior()
- função superior()
- função comprimento()
- função concat()
- função substr()
- função substituir()
- função ifnull()
- função round()
- função ceil()
- função piso()
- função agora()
- função curdate()
- função curtime()
- função ano()
- função mês()
- função dia()
- função hora()
- função minuto()
- função segundo()
- função timestampdiff()
- personagem de fuga
-
- Otimização de SQL
Comandos básicos de operação de banco de dados
Regras de nomenclatura
- Os nomes dos campos devem começar com uma letra
- O comprimento não pode exceder 30 caracteres (diferentes bancos de dados e versões serão diferentes)
- Palavras reservadas SQL não podem ser usadas
- Somente os seguintes caracteres az, AZ, 0-9, $, etc.
- Mysql usa todas as letras minúsculas
- Várias palavras separadas por sublinhados
Operações da biblioteca
| Ordem | descrever |
|---|---|
| mostrar bancos de dados; | Consultar todos os bancos de dados |
| criar banco de dados; | Criar banco de dados |
| use o nome da biblioteca; | Usar biblioteca |
| elimine o nome da biblioteca do banco de dados; | Excluir banco de dados |
Operações de tabela
| Ordem | descrever |
|---|---|
| mostrar tabelas; | Consultar todas as tabelas |
| criar tabela nome da tabela (nome do campo 1 tipo de campo 1 (comprimento), nome do campo 2 tipo de campo 2 (comprimento),...); | Criar a tabela |
| eliminar o nome da tabela; | Excluir tabela |
| alterar tabela nome da tabela adicionar coluna nome do campo tipo de campo (comprimento) | Modificar tabela |
| nome da tabela desc; | Ver estrutura da tabela |
- Ao criar uma tabela, vários campos precisam ser separados por "," vírgulas, mas o último campo não precisa ser
Registrar operações na tabela
| Ordem | descrever |
|---|---|
| selecione o nome do campo 1, o nome do campo 2, o nome do campo 3... no nome da tabela; / selecione * no nome da tabela; | Consultar/consultar todos os dados da tabela com base no nome do campo |
| inserir no nome da tabela valores (valor do campo 1, valor do campo 2,...) / inserir no nome da tabela (nome do campo) valores (valor do campo), (valor do campo) | Adicionar dados à tabela/Adicionar dados ao campo especificado |
| atualizar nome da tabela definir nome do campo = novo valor onde nome do campo = valor do campo | Modifique os dados da tabela, todo o campo será alterado e haverá uma consulta condicional posteriormente |
| excluir do nome da tabela; | Excluir dados da tabela |
| definir nomes gbk; | Resolva caracteres chineses ilegíveis |
| inserir no nome da tabela (nome do campo 1, nome do campo 2,...) valores (valor do campo 1, valor do campo 2,...), (valor do campo 1, valor do campo 2,...) |
Chave primária e incremento automático
- CHAVE PRIMÁRIA AUTO_INCREMENT
Importar estrutura da tabela
1. Selecionar banco de dados
2. Importar sql, fonte xxx.sql
DQL (consulta de dados)
Adicione comentários ao criar tabelas e campos
create table test(id int comment 'id号',name varchar(255) comment '名字')comment='测试表';
Consultar informações da tabela de criação
show create table test;
11. Consulta simples.
Qualquer instrução SQL termina com ";".
As instruções SQL não diferenciam maiúsculas de minúsculas, mas os dados armazenados na tabela são divididos em tamanhos diferentes no Oracle. O MySQL não faz distinção. O Oracle é mais rigoroso e o MySQL é mais solto.
Os campos podem participar de operações matemáticas
usando como seu alias, e a palavra-chave as pode ser omitida. Se houver chinês no alias, use aspas simples para colocar a string
na instrução sql. A string deve ser colocada entre aspas simples . Use
"," para consultar vários campos.
Use "*" para separar todos os campos na consulta. No desenvolvimento real, não é recomendado usar " * ", que é menos eficiente.
12. Consulta condicional
selecione
campo, campo...
do
nome da tabela
onde
condição;
ordem de execução: de, onde, selecione
entre…e…: É um intervalo fechado [1100 - 3000]
entre…e…: Quando usado, deve ser pequeno à esquerda e grande à direita.
entre…e…: Pode ser usado em números e strings, mas é fechado à esquerda em termos de caracteres. Abertura direita [A - C)
NULL não é um valor no banco de dados, não significa nada e está vazio.
O vazio não é um valor e não pode ser medido com sinal de igual.
Deve usar é nulo ou não é nulo
e tem maior prioridade que ou, você pode usar colchetes "()" para resolver o problema de prioridade
O valor após in não é um intervalo, mas um valor específico
Na consulta difusa, se quiser consultar o conteúdo com "_", você pode usar os caracteres de transferência "\", "\_" e pronto.
13. Ordenação de classificação (crescente, decrescente)
por campo asc/desc
O padrão é ordem crescente
asc ordem crescente ordem
decrescente
. Use " , " para separar vários campos ao mesmo tempo. Os
campos anteriores podem desempenhar um papel principal. Somente quando os campos anteriores não puderem completar a classificação, os campos posteriores serão habilitados . (Quando os campos anteriores forem iguais, os campos seguintes serão executados.)
Você pode ordenar pelo número do campo e pode classificar de acordo com o número do campo (o número do campo é o campo usado na consulta), mas não é recomendado para usá-lo em programas Java. Ele pode ser usado na prática diária.
selecione
o campo
da
superfície
onde
a condição
ordenar por
...
Ordem de execução: de, onde, selecionar, ordenar por
Nota: ordenar por é executado por último
14. Função de agrupamento
contagem contagem
soma soma
valor médio valor
máximo máximo valor
mínimo valor mínimo
Nota: Todas as funções de agrupamento operam em um determinado conjunto de dados. Existem
5 funções de agrupamento no total.
A função de agrupamento tem outro nome, função de processamento multilinha.
Recursos da função de processamento multilinha: entrada de várias linhas, o resultado final da saída é uma linha.
A função de agrupamento ignora automaticamente NULL
. Todas as funções de agrupamento ignoram automaticamente NULL, então não há não há necessidade de adicioná-lo à condição where. A condição de filtro acima não é nula
select sum(comm) from emp; A função sum ignora automaticamente NULL.
Há uma regra de sintaxe na instrução SQL. A função de agrupamento não pode ser usada diretamente na cláusula where?
Motivo: porque group by é executado após where ser executado.
Ordem de execução: onde, agrupar por, função de grupo (sem agrupar por, a função de grupo não pode ser usada), portanto a função de grupo não pode ser usada na cláusula where.
Qual é a diferença entre count( * ) e count(um determinado campo)?
contagem (*): não conta o número de dados em um determinado campo, mas conta o número total de registros, o que não tem nada a ver com um determinado campo. contagem (um determinado campo): significa contar o número total de
dados em um determinado campo que não é NULL.
As funções de agrupamento podem ser combinadas e separadas por " , "
A função de agrupamento irá ignorar NULL, mas a expressão matemática não irá ignorar NUL. O resultado de qualquer expressão matemática com NULL deve ser NULL.
15. A função de processamento de linha única
insere uma linha e gera uma linha.Nota
: No banco de dados, desde que NULL apareça na expressão matemática, o resultado será NULL e NULL não será ignorado na expressão matemática.
Solução: função de processamento nulo ifnull(), que pertence à função de processamento de linha única
ifnull (como os dados NULL devem ser tratados)
16. agrupar por e agrupar
por: Agrupar por um determinado campo ou determinados campos.
tendo: é filtrar os dados após agrupar novamente.
Nota: agrupar por e ter são parceiros. Se quiser usar tendo, você deve usar agrupar por.
Ordem de execução: from, group by, select (função de agrupamento)
Nota: As funções de agrupamento são geralmente usadas em conjunto com group by. Qualquer função de agrupamento não será executada até que a instrução group by seja executada.
Quando uma instrução SQL não possui um grupo por, os dados de toda a tabela formarão um grupo próprio. Na verdade, haverá um grupo por padrão nela.
Quando há group by em uma instrução, apenas os campos e funções de agrupamento de parâmetros que podem aparecer após o select são escritos aqui. Outros não são permitidos. Embora possa ser executado no MySQL, não faz sentido. Se executado no Oracle, um erro será relatado.
A consulta de grupo de vários campos
apenas trata vários campos como um único campo.
selecione
deptno,job,max(sal)
do grupo
emp por deptno,job;
Onde a filtragem é maior do que ter filtragem.
Recomenda-se usar onde, se puder.
17. Resuma uma instrução DQL completa
selecione 5 campos de consulta
...
de 1 tabela de consulta
...
onde 2 filtros de condições
...
agrupar por 3 grupos
...
tendo 4 filtros de condições
...
ordenar por 6 classificar
...
1. Remova registros duplicados
distintos.
select distinct job from emp;
select distinct deptno,job from emp;
distinto só pode aparecer na frente de todos os campos e vários campos serão combinados para eliminar duplicação.
Contar o número de empregos?
select count(distinct job) from emp;
2. Visão geral da consulta de conexão
:
No desenvolvimento real, a maioria dos dados não é consultada em uma única tabela, mas geralmente é uma consulta conjunta de várias tabelas.
Como há muitos campos em uma tabela, uma grande quantidade de dados será repetida, resultando em redundância de dados.
3. Classificação:
Junção interna: As duas tabelas AB têm um relacionamento igual e não há distinção entre tabelas primárias e secundárias.
Junções equivalentes
. Junções não equivalentes.
Auto-junções
. Junções externas: As duas tabelas AB são divididas em primárias. tabelas e tabelas secundárias. A tabela principal é verificada. Junções à esquerda podem ser escritas como junções à direita, junções à direita podem ser escritas como junções à esquerda, junções externas à esquerda (junções à esquerda),
junções
externas à direita (junções à direita)
e junções completas: quase nunca usado. Existem junções à esquerda e à direita para descobrir todos os dados nas duas tabelas.
4. Fenômeno do produto de Descartes (fenômeno do produto cartesiano):
Em relação aos aliases de tabelas:
alta eficiência de execução
e boa legibilidade
14 x 4 = 56 entradas
select e.ename,d.dname from emp e,dept d;
Evite o fenômeno do produto cartesiano: o número de correspondências ainda é 56 (o número de correspondências não será reduzido), mas apenas registros válidos são exibidos.
Descubra o nome do departamento de cada funcionário e exija que o nome do funcionário e o nome do departamento sejam exibidos.
select e.ename,d.dname from emp e,dept d where e.deptno=d.deptno; # SQL92，以后不用
5.
A maior característica das junções internas e junções equivalentes é que a condição é uma relação de equivalência.
Descubra o nome do departamento de cada funcionário e exija que o nome do funcionário e o nome do departamento sejam exibidos.
SQL92: (não usado)
select
e.ename,d.dname
from
emp e,dept d
where
e.deptno=d.deptno; # SQL92，以后不用
SQL99: (comumente usado)
select
e.ename,d.dname
from
emp e
join
dept d
on
e.deptno=d.deptno;
inner: Indica conexão interna, inner pode ser omitido e o objetivo de inner é melhorar a legibilidade.
select
e.ename,d.dname
from
emp e
inner join
dept d
on
e.deptno=d.deptno;
...
Uma
junção
B
na
condição de conexão
onde
...
a estrutura é mais clara, a condição de conexão da tabela é separada da condição onde subsequente
6.
A maior característica das junções não equivalentes em junções internas é que o relacionamento na condição de junção não é equivalente.
Para saber a faixa salarial de cada funcionário, é necessário exibir o nome do funcionário, salário e faixa salarial.
select
e.ename,e.sal,s.grade
from
emp e
join
salgrade s
on
e.sal between s.losal and s.hisal;
7.
A maior característica da auto-junção é: uma mesa é considerada como duas mesas e elas se unem.
As auto-junções de tabelas podem ser iguais ou desiguais.
empno: número do funcionário
ename: nome do funcionário e nome do líder
mgr: número do líder
select empno,ename,mgr from emp;
emp a 员工表
±------±-------±-----+
| empregado | nomear | mgr |
±------±-------±-----+
| 7369 | SMITH | 7902 |
| 7499 | ALLEN | 7698 |
| 7521 | ALA | 7698 |
| 7566 | JONES | 7839 |
| 7654 | MARTIN | 7698 |
| 7698 | BLAKE | 7839 |
| 7782 | CLARO | 7839 |
| 7788 | SCOTT | 7566 |
| 7839 | REI | NULO |
| 7844 | TORNEADOR | 7698 |
| 7876 | ADAM | 7788 |
| 7900 | Tiago | 7698 |
| 7902 | FORD | 7566 |
| 7934 | MILEIRO | 7782 |
±------±-------±-----+
select empno,ename from emp;
emp b tabela de liderança
±------±-------±
| empno | ename |
±------±-------+
| 7566 | JONES |
| 7698 | BLAKE |
| 7782 | CLARK |
| 7788 | SCOTT |
| 7839 | KING |
| 7902 | FORD |
±------±-------+
Encontre o líder superior de cada funcionário e exija que o nome do funcionário e o nome do líder correspondente sejam exibidos.
select
a.ename as '员工名',b.ename as '领导名'
from
emp a
inner join
emp b
on
a.mgr = b.empno;
8. Junção externa (comumente usada)
Qual é a diferença entre junção interna e junção externa?
Junção interna:
Suponha que as tabelas A e B estejam conectadas. Se você usar a junção interna, todos os registros que podem ser correspondidos entre a tabela A e a tabela poderão ser consultados. Esta é uma junção interna.
Não há distinção entre as tabelas primária e secundária AB. As duas tabelas são iguais.
Junção externa:
suponha que as tabelas A e B estejam conectadas. Se você usar uma junção externa, uma das duas tabelas AB é a tabela principal e a outra é a tabela secundária. Os dados na tabela principal são consultados principalmente, e a secundária a tabela é consultada como uma tabela secundária. Os dados contidos não correspondem aos dados da tabela principal e a tabela secundária simula automaticamente NULL para combiná-los.
Classificação de junção externa:
Junção externa esquerda (junção esquerda): indica que a tabela à esquerda é a tabela principal.
Junção externa direita (junção direita): Indica que a tabela à direita é a tabela principal.
As junções à esquerda são escritas na forma de junções à direita, e as junções à direita também são escritas no formulário de junção à esquerda correspondente.
Descubra quem é o superior de cada funcionário? (Todos os funcionários devem ser consultados)
Junção externa esquerda (tabela a é a tabela principal, tabela b é a tabela secundária)
junção externa externa pode ser omitida, a maneira de distinguir junções internas e externas é através da esquerda e da direita são junções externas
select
a.ename as '员工名',b.ename as '领导名'
from
emp a
left outer join
emp b
on
a.mgr = b.empno;
Junção externa direita (tabela a é a tabela principal, tabela b é a tabela secundária)
select
a.ename as '员工名',b.ename as '领导名'
from
emp b
right outer join
emp a
on
a.mgr = b.empno;
Conexões externas são frequentemente usadas.
O recurso mais importante das conexões externas é que todos os dados da tabela principal podem ser consultados incondicionalmente.
Descubra qual departamento não tem funcionários.
select
d.*
from
emp e
right join
dept d
on
e.deptno=d.deptno
where
e.empno is null;
9. Junte a consulta entre três tabelas
para descobrir o nome do departamento e a faixa salarial de cada funcionário.
tabela de funcionários emp e
mysql> select empno,ename,sal,deptno from emp;
+-------+--------+---------+--------+
| empno | ename | sal | deptno |
+-------+--------+---------+--------+
| 7369 | SMITH | 800.00 | 20 |
| 7499 | ALLEN | 1600.00 | 30 |
| 7521 | WARD | 1250.00 | 30 |
| 7566 | JONES | 2975.00 | 20 |
| 7654 | MARTIN | 1250.00 | 30 |
| 7698 | BLAKE | 2850.00 | 30 |
| 7782 | CLARK | 2450.00 | 10 |
| 7788 | SCOTT | 3000.00 | 20 |
| 7839 | KING | 5000.00 | 10 |
| 7844 | TURNER | 1500.00 | 30 |
| 7876 | ADAMS | 1100.00 | 20 |
| 7900 | JAMES | 950.00 | 30 |
| 7902 | FORD | 3000.00 | 20 |
| 7934 | MILLER | 1300.00 | 10 |
+-------+--------+---------+--------+
14 rows in set (0.00 sec)
tabela de departamento do departamento
mysql> select * from dept;
+--------+------------+----------+
| DEPTNO | DNAME | LOC |
+--------+------------+----------+
| 10 | ACCOUNTING | NEW YORK |
| 20 | RESEARCH | DALLAS |
| 30 | SALES | CHICAGO |
| 40 | OPERATIONS | BOSTON |
+--------+------------+----------+
4 rows in set (0.00 sec)
Grau salarial de Salgrade
mysql> select * from salgrade;
+-------+-------+-------+
| GRADE | LOSAL | HISAL |
+-------+-------+-------+
| 1 | 700 | 1200 |
| 2 | 1201 | 1400 |
| 3 | 1401 | 2000 |
| 4 | 2001 | 3000 |
| 5 | 3001 | 9999 |
+-------+-------+-------+
5 rows in set (0.00 sec)
A
junta-se
a B
junta-se
a C
em
Isso significa: a Tabela A e a Tabela B são conectadas primeiro, e após a conexão (o resultado após a conexão), a Tabela A continua conectada à Tabela C.
select
e.ename,d.dname,s.grade
from
emp e
join
dept d
on
e.deptno=d.deptno
join
salgrade s
on
e.sal between s.losal and s.hisal;
+--------+------------+-------+
| ename | dname | grade |
+--------+------------+-------+
| SMITH | RESEARCH | 1 |
| ALLEN | SALES | 3 |
| WARD | SALES | 2 |
| JONES | RESEARCH | 4 |
| MARTIN | SALES | 2 |
| BLAKE | SALES | 4 |
| CLARK | ACCOUNTING | 4 |
| SCOTT | RESEARCH | 4 |
| KING | ACCOUNTING | 5 |
| TURNER | SALES | 3 |
| ADAMS | RESEARCH | 1 |
| JAMES | SALES | 1 |
| FORD | RESEARCH | 4 |
| MILLER | ACCOUNTING | 2 |
+--------+------------+-------+
14 rows in set (0.00 sec)
Descubra o nome do departamento, a faixa salarial e o supervisor de cada funcionário.
#e é a tabela principal, e1 é a tabela secundária
select
e.ename '员工',d.dname,s.grade,e1.ename '领导'
from
emp e
join
dept d
on
e.deptno=d.deptno
join
salgrade s
on
e.sal between s.losal and s.hisal
left join
emp e1
on
e.mgr=e1.empno;
+--------+------------+-------+-------+
| 员工 | dname | grade | 领导 |
+--------+------------+-------+-------+
| SMITH | RESEARCH | 1 | FORD |
| ALLEN | SALES | 3 | BLAKE |
| WARD | SALES | 2 | BLAKE |
| JONES | RESEARCH | 4 | KING |
| MARTIN | SALES | 2 | BLAKE |
| BLAKE | SALES | 4 | KING |
| CLARK | ACCOUNTING | 4 | KING |
| SCOTT | RESEARCH | 4 | JONES |
| KING | ACCOUNTING | 5 | NULL |
| TURNER | SALES | 3 | BLAKE |
| ADAMS | RESEARCH | 1 | SCOTT |
| JAMES | SALES | 1 | BLAKE |
| FORD | RESEARCH | 4 | JONES |
| MILLER | ACCOUNTING | 2 | CLARK |
+--------+------------+-------+-------+
14 rows in set (0.00 sec)
3. Subconsulta
1. O que é uma subconsulta? Onde a subconsulta aparecerá?
As instruções select são aninhadas nas instruções select, e as instruções select aninhadas são subconsultas.
Onde aparece:
selecione
…(selecione)
de
…(selecione)
onde
…(selecione)
2. Use subconsulta na cláusula where
Encontre informações sobre funcionários que ganham mais do que o salário médio.
Etapa 1: Encontre o salário médio.
select avg(sal) from emp;
+-------------+
| avg(sal) |
+-------------+
| 2073.214286 |
+-------------+
1 row in set (0.00 sec)
Etapa 2: onde filtrar
select * from emp where sal>2073.214286;
+-------+-------+-----------+------+------------+---------+------+--------+
| EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
+-------+-------+-----------+------+------------+---------+------+--------+
| 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
| 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
| 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
| 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
| 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
| 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
+-------+-------+-----------+------+------------+---------+------+--------+
6 rows in set (0.00 sec)
Etapa 3: mesclar
select * from emp where sal>(select avg(sal) from emp);
+-------+-------+-----------+------+------------+---------+------+--------+
| EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
+-------+-------+-----------+------+------------+---------+------+--------+
| 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
| 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
| 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
| 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
| 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
| 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
+-------+-------+-----------+------+------------+---------+------+--------+
6 rows in set (0.00 sec)
3. Subconsulta aninhada atrás de
Encontre a faixa salarial para o salário médio em cada departamento.
Passo 1: Encontre o salário médio de cada departamento (agrupe de acordo com o número do departamento e encontre o salário médio)
select deptno,avg(sal) as avgsal from emp group by deptno;
+--------+-------------+
| deptno | avgsal |
+--------+-------------+
| 20 | 2175.000000 |
| 30 | 1566.666667 |
| 10 | 2916.666667 |
+--------+-------------+
3 rows in set (0.00 sec)
Etapa 2: trate o resultado da consulta acima como uma tabela temporária t e conecte a tabela t à tabela salgrade s. A condição é: t.avgsal entre s.losal e s.hisal
select
t.*,s.grade
from
(select deptno,avg(sal) as avgsal from emp group by deptno) t
join
salgrade s
on
t.avgsal between s.losal and s.hisal;
+--------+-------------+-------+
| deptno | avgsal | grade |
+--------+-------------+-------+
| 20 | 2175.000000 | 4 |
| 30 | 1566.666667 | 3 |
| 10 | 2916.666667 | 4 |
+--------+-------------+-------+
3 rows in set (0.00 sec)
Encontre a faixa salarial média de cada departamento.
Passo 1: Descubra a faixa salarial de cada funcionário.
tabela de funcionários emp e
mysql> select ename,sal from emp;
+--------+---------+
| ename | sal |
+--------+---------+
| SMITH | 800.00 |
| ALLEN | 1600.00 |
| WARD | 1250.00 |
| JONES | 2975.00 |
| MARTIN | 1250.00 |
| BLAKE | 2850.00 |
| CLARK | 2450.00 |
| SCOTT | 3000.00 |
| KING | 5000.00 |
| TURNER | 1500.00 |
| ADAMS | 1100.00 |
| JAMES | 950.00 |
| FORD | 3000.00 |
| MILLER | 1300.00 |
+--------+---------+
14 rows in set (0.00 sec)
tabela de notas de salgrado
mysql> select * from salgrade;
+-------+-------+-------+
| GRADE | LOSAL | HISAL |
+-------+-------+-------+
| 1 | 700 | 1200 |
| 2 | 1201 | 1400 |
| 3 | 1401 | 2000 |
| 4 | 2001 | 3000 |
| 5 | 3001 | 9999 |
+-------+-------+-------+
5 rows in set (0.00 sec)
mysql> select e.ename,e.sal,e.deptno,s.grade from emp e join salgrade s on e.sal between s.losal and s.hisal;
+--------+---------+--------+-------+
| ename | sal | deptno | grade |
+--------+---------+--------+-------+
| SMITH | 800.00 | 20 | 1 |
| ALLEN | 1600.00 | 30 | 3 |
| WARD | 1250.00 | 30 | 2 |
| JONES | 2975.00 | 20 | 4 |
| MARTIN | 1250.00 | 30 | 2 |
| BLAKE | 2850.00 | 30 | 4 |
| CLARK | 2450.00 | 10 | 4 |
| SCOTT | 3000.00 | 20 | 4 |
| KING | 5000.00 | 10 | 5 |
| TURNER | 1500.00 | 30 | 3 |
| ADAMS | 1100.00 | 20 | 1 |
| JAMES | 950.00 | 30 | 1 |
| FORD | 3000.00 | 20 | 4 |
| MILLER | 1300.00 | 10 | 2 |
+--------+---------+--------+-------+
14 rows in set (0.00 sec)
Etapa 2: com base nos resultados acima, continue agrupando por departamento e encontre a nota média.
select
e.deptno,avg(s.grade)
from
emp e
join
salgrade s
on
e.sal between s.losal and s.hisal
group by
e.deptno;
+--------+--------------+
| deptno | avg(s.grade) |
+--------+--------------+
| 20 | 2.8000 |
| 30 | 2.5000 |
| 10 | 3.6667 |
+--------+--------------+
3 rows in set (0.00 sec)
4. Subconsulta aninhada após seleção
Descubra o nome do departamento de cada funcionário e exija que o nome do funcionário e o nome do departamento sejam exibidos.
Os resultados a seguir são iguais
select
e.ename,d.dname
from
emp e
join
dept d
on
e.deptno=d.deptno;
select
e.ename,(select d.dname from dept d where e.deptno = d.deptno) as dname
from
emp e;
+--------+------------+
| ename | dname |
+--------+------------+
| SMITH | RESEARCH |
| ALLEN | SALES |
| WARD | SALES |
| JONES | RESEARCH |
| MARTIN | SALES |
| BLAKE | SALES |
| CLARK | ACCOUNTING |
| SCOTT | RESEARCH |
| KING | ACCOUNTING |
| TURNER | SALES |
| ADAMS | RESEARCH |
| JAMES | SALES |
| FORD | RESEARCH |
| MILLER | ACCOUNTING |
+--------+------------+
14 rows in set (0.00 sec)
4. Sindicato (você pode adicionar os conjuntos de resultados da consulta)
para descobrir os funcionários cujos cargos salariais são VENDEDOR e GERENTE?
O primeiro tipo: ou
select ename,job from emp where job='MANAGER' or job='SALESMAN';
O segundo tipo: em
select ename,job from emp where job in('MANAGER','SALESMAN');
+--------+----------+
| ename | job |
+--------+----------+
| ALLEN | SALESMAN |
| WARD | SALESMAN |
| JONES | MANAGER |
| MARTIN | SALESMAN |
| BLAKE | MANAGER |
| CLARK | MANAGER |
| TURNER | SALESMAN |
+--------+----------+
7 rows in set (0.00 sec)
O terceiro tipo: união
select ename,job from emp where job = 'MANAGER' union select ename,job from emp where job = 'SALESMAN';
+--------+----------+
| ename | job |
+--------+----------+
| JONES | MANAGER |
| BLAKE | MANAGER |
| CLARK | MANAGER |
| ALLEN | SALESMAN |
| WARD | SALESMAN |
| MARTIN | SALESMAN |
| TURNER | SALESMAN |
+--------+----------+
7 rows in set (0.01 sec)
união: os dados de duas tabelas não relacionadas são unidos e exibidos.
união: O número de campos após a seleção deve ser o mesmo quando usado.
5. O limite de consulta de paginação
é exclusivo do mysql e não está disponível em outros bancos de dados, portanto não será aprovado. (Existe um mecanismo semelhante no Oracle, chamado rownum)
limit faz parte dos dados do conjunto de resultados. Esta é a sua função.
Mecanismo de sintaxe:
limite startIndex, comprimento
startIndex indica a posição inicial, começando em 0, 0 indica o primeiro dado,
comprimento indica quantos pegar, se você escrever um número diretamente, o valor padrão é 0.
Retire os 5 melhores funcionários por salário (ideia: pegue os 5 melhores em ordem decrescente)
select ename,sal from emp order by sal desc;
# 取前5个 limit 0,5
select ename,sal from emp order by sal desc limit 0,5;
+-------+---------+
| ename | sal |
+-------+---------+
| KING | 5000.00 |
| FORD | 3000.00 |
| SCOTT | 3000.00 |
| JONES | 2975.00 |
| BLAKE | 2850.00 |
+-------+---------+
5 rows in set (0.00 sec)
# 取前5个，limit 5，直接写一个数字的话，前面默认就是0
select ename,sal from emp order by sal desc limit 5;
+-------+---------+
| ename | sal |
+-------+---------+
| KING | 5000.00 |
| FORD | 3000.00 |
| SCOTT | 3000.00 |
| JONES | 2975.00 |
| BLAKE | 2850.00 |
+-------+---------+
5 rows in set (0.00 sec)
limitista é a última etapa na execução da instrução sql
select 5
...
from 1
...
where 2
...
group by 3
...
having 4
...
order by 6
...
limit 7
...
Encontre os funcionários cujo salário vai do 4º ao 9º lugar?
select ename,sal from emp order by sal desc limit 3,6;
+--------+---------+
| ename | sal |
+--------+---------+
| JONES | 2975.00 |
| BLAKE | 2850.00 |
| CLARK | 2450.00 |
| ALLEN | 1600.00 |
| TURNER | 1500.00 |
| MILLER | 1300.00 |
+--------+---------+
6 rows in set (0.00 sec)
6. SQL de paginação padrão comum?
Cada página exibe 3 registros:
Página 1: 0, 3 (0, 1,
2) Página 2: 3, 3 (3, 4, 5)
Página 3: 6, 3 (6, 7, 8
) Página 4: 9, 3 (9, 10, 11)
Página 5: 12, 3 (12, 13, 14)
Exibir registros pageSize por página:
pageNo: (pageNo - 1) * pageSize, pageSize
pageNo: qual página é exibida
pageSize: quantos registros são exibidos em cada página
java代码{
int pageNo = 2; // 页码2
int pageSize = 10; // 每页显示10条
limit (pageNo - 1) * pageSize, pageSize
limit (2 - 1) * 10, pageSize
limit 10,10
}
6. Crie
um formato de sintaxe de tabela:
create table 表名(
字段名1 数据类型,
字段名2 数据类型,
字段名3 数据类型,
......
);
Em relação aos tipos de dados de campos no MySQL, os tipos de dados comuns são
int tipo inteiro (int em Java)
bigint tipo inteiro longo (long em Java)
float tipo de ponto flutuante (float double em Java)
char string de comprimento fixo (String)
varchar string de comprimento variável (StringBuffer StringBuilder) 255
data tipo de data (tipo java.sql.Date em Java)
objeto binário grande blob (armazenamento de informações de mídia, como imagens e vídeos) (objeto em Java)
objeto grande de caractere clob (armazenamento texto maior , por exemplo, pode armazenar string 4G) (Objeto em Java)
Como escolher entre char e varchar?
No desenvolvimento real, quando o comprimento dos dados em um determinado campo não muda, é um comprimento fixo.Por exemplo, sexo, aniversário, etc., são todos caracteres.
Quando o comprimento dos dados de um campo é incerto, como introdução, nome, etc., varchar é usado.
Uso de tipos blob e clob?
Você precisa usar streaming de IO.
Os tipos de mídia geralmente não os colocam diretamente no banco de dados. Em vez disso, os dados do tipo de mídia são colocados no banco de dados por meio de um caminho, que geralmente usa o tipo char ou varchar.
Tabela de filmes: t_movie
id (int) nome (varchar) playtime (data/char) haibao (blob) histórico (clob)
1 Homem-Aranha
2
3
Geralmente é recomendado que o nome da tabela no banco de dados comece com t_ ou tbl_
Crie uma tabela de alunos:
as informações do aluno incluem:
ID do aluno, nome, sexo, número da turma, aniversário
ID do aluno: bigint
Nome: varchar
Gênero: char
ID da turma: varchar
Aniversário: char
create table t_student(
no bigint,
name varchar(255),
sex char(1),
classno varchar(255),
birth char(10)
);
7. A instrução insert insere dados.Formato
de sintaxe:
Requisitos: O número de campos e o número de valores são iguais, e os tipos de dados devem ser os mesmos.
insert into 表名(字段名1,字段名2,字段名3,...) values(值1,值2,值3,...);
insert into t_student(no,name,sex,classno,birth) values(1,'zhangsan','1','gaosan1ban','1950-10-12');
A ordem dos campos pode ser alterada, mas a frente e o verso devem corresponder.
insert into t_student(name,sex,classno,birth,no) values('lisi','1','gaosan1ban','1950-10-12',2);
Você pode escrever um campo e NULL será inserido automaticamente em todos os campos restantes.
insert into t_student(name) values('wangwu');
drop table if exist t_student; # Exclui o valor padrão quando esta tabela existir
create table t_student(
no bigint,
name varchar(255),
sex char(1) default 1,
classno varchar(255),
birth char(10)
);
insert into t_student(name) values('zhangsan');
select * from t_student;
+------+----------+------+---------+-------+
| no | name | sex | classno | birth |
+------+----------+------+---------+-------+
| NULL | zhangsan | 1 | NULL | NULL |
+------+----------+------+---------+-------+
Nota: Quando uma instrução insert é executada com sucesso, inevitavelmente haverá mais uma linha de registros na tabela.
Mesmo que alguns campos nesta linha de registros sejam NULL, não há como executá-lo posteriormente.
A instrução insert insere dados e só pode ser atualizada usando update.
Os campos podem ser omitidos, mas os valores a seguir possuem requisitos de quantidade e pedido.
insert into t_student values(1,'jack','0','gaosan2ban','1986-10-23');
Insira vários registros
insert into t_student
(no,name,sex,classno,birth)
values
(3,'rose','1','gaosi2ban','1952-12-14'),
(4,'laotie','1','gaosi2ban','1952-12-19');
8.
Sintaxe de cópia de tabela:
create table 表面 as select语句;
Crie os resultados da consulta como uma tabela.
create table emp1 as select * from emp;
create table emp2 as select empno,ename from emp;
9. Insira os resultados da consulta em uma tabela.
Existem requisitos para inserção de campos e o número de campos deve corresponder.
insert into dept1 select * from dept;
10. Modifique os dados: atualize
o formato da sintaxe:
update 表名 set 字段名1=值1,字段名2=值2... where 条件;
Nota: Não há condição para que todos os dados da tabela inteira sejam atualizados.
Altere o LOC do departamento 10 para SHANGHAI e o nome do departamento para RENSHIBU
update dept1 set loc='SHANGHAI',dname='RENSHIBU' where deptno=10;
Atualizar todos os registros
update dept1 set loc='x', dname='y';
11. Exclua
o formato da sintaxe dos dados:
delete from 表名 where 条件；
Nota: Exclua tudo sem condições.
Excluir dados de 10 departamentos?
delete from dept1 where deptno=10;
Excluir todos os registros?
delete from dept1;
Como deletar uma mesa grande? (ênfase)
truncate table emp1; # 表被截断，不可回滚，永久丢失。
12. Modifique a estrutura da tabela
. Basta usar a ferramenta diretamente. Em circunstâncias normais, uma vez projetada a tabela, a estrutura da tabela raramente precisa ser modificada.
Instruções que modificam a estrutura da tabela não aparecerão no código Java, apenas insert delete update select, que são todas operações de dados na tabela.
Existe um termo para adicionar, excluir, modificar e consultar: operação CRUD
criar (adicionar)
Recuperar (recuperar)
Atualizar (modificar)
Excluir (excluir)
13. Restrição
O que é uma restrição? Quais são as restrições comuns?
Ao criar uma tabela, você pode adicionar restrições correspondentes aos campos da tabela. O objetivo de adicionar restrições é garantir a legalidade, validade e integridade dos dados da tabela.
Quais são as restrições comuns?
Restrição não nula (não nula): O campo restrito não pode ser NULO.
Restrição única: O campo restrito não pode ser repetido.
Restrição de chave primária (chave primária): O campo restrito não pode ser NULO ou repetido (referido como PK).
Estrangeiro restrição de chave (chave estrangeira):... (referida como FK)
restrição de verificação (cheque): Observe que o banco de dados Oracle possui uma restrição de verificação, mas o MySQL não. Atualmente, o MySQL não suporta esta restrição.
14. Restrição não nula não nula
drop table if exists t_user;
create table t_user(
id int,
username varchar(255) not null,
password varchar(255)
);
insert into t_user(id,username,password) values(1,'lisi','123');
1. Restrição única (única)
O campo modificado pela restrição única é único e não pode ser repetido. Mas pode ser NULO.
Restrições no nível da coluna
Restrições no nível da tabela
Caso: Adicionar exclusivo a uma determinada coluna
drop table if exists t_user;
create table t_user(
id int,
username varchar(255) unique # 列级约束，可以使用表级约束来添加一个字段，效果一样
);
insert into t_user values(1,'zhangsan');
insert into t_user values(2,'zhangsan'); # ERROR 1062 (23000): Duplicate entry 'zhangsan' for key 'username'（字段重复报错 ）
insert into t_user(id) values(2);
insert into t_user(id) values(3);
insert into t_user(id) values(4);
Caso: Adicione exclusivo a duas ou mais colunas
drop table if exists t_user;
create table t_user(
id int,
usercode varchar(255),
username varchar(255),
unique(usercode,username) # 多个字段联合起来添加约束，不能重复，就添加了一个约束（表级约束）
);
insert into t_user values(1,'111','zs');
insert into t_user values(2,'111','ls');
insert into t_user values(3,'222','zs');
insert into t_user values(3,'111','zs'); # ERROR 1062 (23000): Duplicate entry '111-zs' for key 'usercode'
select * from t_user;
drop table if exists t_user;
create table t_user(
id int,
usercode varchar(255) unique,
username varchar(255) unique
);
insert into t_user values(1,'111','zs');
insert into t_user values(2,'111','ls'); # ERROR 1062 (23000): Duplicate entry '111' for key 'usercode'
select * from t_user;
Nota: restrições não nulas possuem apenas restrições em nível de coluna, não restrições em nível de tabela.
2. Restrições de chave primária
Como adicionar restrições de chave primária a uma tabela?
drop table if exists t_user;
create table t_user(
id int primary key, // 列级约束
username varchar(255),
email varchar(255)
);
insert into t_user(id,username,email) values(1,'zs','[email protected]');
insert into t_user(id,username,email) values(2,'ls','[email protected]');
insert into t_user(id,username,email) values(3,'ww','[email protected]');
select * from t_user;
insert into t_user(id,username,email) values(1,'jack','[email protected]'); # ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'
insert into t_user(username,email) values('jack','[email protected]'); # ERROR 1364 (HY000): Field 'id' doesn't have a default value
Resumo: id é a chave primária. Como a restrição da chave primária é adicionada, os dados no campo da chave primária não podem ser NULOS ou repetidos.
Características da chave primária: Não pode ser NULL ou repetida (única).
Terminologia relacionada à chave primária:
Restrição de chave primária: chave primária
Campo de chave primária: Depois de adicionar a chave primária ao campo id, id é chamado de campo de chave primária
Valor da chave primária: Cada valor no campo id é o valor da chave primária
Qual é o papel da chave primária:
Existem requisitos nos três paradigmas de design de tabela. O primeiro paradigma exige que qualquer tabela tenha uma chave primária.
A função da chave primária: O valor da chave primária é o identificador exclusivo desta linha registrada nesta tabela. (Assim como o número de identificação de uma pessoa)
Classificação de chaves primárias:
dividida de acordo com o número de campos no campo de chave primária:
chave primária única (recomendado, comumente usado)
chave primária composta (vários campos combinados para adicionar uma restrição de chave primária) (chaves primárias compostas não são recomendadas porque compostas as chaves primárias violam os três paradigmas) de acordo com a
natureza da chave primária Para dividir:
Chave primária natural: O valor da chave primária é preferencialmente um número natural que não tem nada a ver com o negócio. (Recomendado, comumente usado)
Chave primária comercial: O valor da chave primária está vinculado ao negócio do sistema. Por exemplo, use o número do cartão bancário como chave primária e o número do cartão de identificação como chave primária. (Não recomendado)
É melhor não usar campos vinculados ao negócio como chaves primárias. Porque uma vez que o negócio mude no futuro, o valor da chave primária também pode precisar ser alterado, mas às vezes não há como alterá-lo, porque a alteração pode fazer com que o valor da chave primária seja repetido.
Uma tabela só pode ter uma restrição de chave primária. (Deve lembrar)
Defina a chave primária usando restrições em nível de tabela:
drop table if exists t_user;
create table t_user(
id int,
username varchar(255),
primary key(id)
);
insert into t_user(id,username) values(1,'zs');
insert into t_user(id,username) values(2,'ls');
insert into t_user(id,username) values(3,'ww');
insert into t_user(id,username) values(4,'cs');
select * from t_user;
insert into t_user(id,username) values(4,'cs'); # ERROR 1062 (23000): Duplicate entry '4' for key 'PRIMARY'
mysql fornece incremento automático de valor de chave primária: (auto_increment) (ênfase)
drop table if exists t_user;
create table t_user(
id int primary key auto_increment, # id字段自动维护一个自增的数据，从1开始，以1递增。
username varchar(255)
);
insert into t_user(username) values('a');
insert into t_user(username) values('b');
insert into t_user(username) values('c');
insert into t_user(username) values('e');
insert into t_user(username) values('e');
insert into t_user(username) values('f');
select * from t_user;
Dica: O Oracle também fornece um mecanismo de incremento automático chamado: objeto de sequência.
3. Restrições de chave estrangeira
Termos relacionados:
Restrições de chave estrangeira: chave estrangeira, o valor na restrição de chave estrangeira não pode ser escrito acidentalmente, deve vir do valor de um campo em uma determinada tabela e o campo referenciado deve ser único.
Campo de chave estrangeira: Adicione um campo com uma restrição de chave estrangeira
Valor de chave estrangeira: Cada valor no campo de chave estrangeira
Histórico de negócios:
Por favor, crie uma tabela de banco de dados para manter as informações dos alunos e da turma?
A primeira opção: uma tabela armazena todos os datano
(pk) nome classno classname
1 zs1 101 Classe 1, 3ª série, Yizhuang No. 2 Middle School, Zona de Desenvolvimento Econômico e Tecnológico do Distrito de Daxing,
Pequim 2 zs2 101 Classe 1, 3ª série, Yizhuang Escola Secundária Nº 2, Zona de Desenvolvimento Econômico e Tecnológico do Distrito de Daxing, Pequim
3 zs3 102 Classe 2, Classe 2, Sênior 3, Yizhuang Escola Secundária Nº 2, Zona de Desenvolvimento Econômico e Tecnológico, Distrito de Daxing, Pequim 4 zs4
102 Classe 2, Classe 3, Sênior 3, Escola Secundária Yizhuang No. 2, Zona de Desenvolvimento Econômico e Tecnológico do Distrito de Daxing, Pequim 5 zs5 102 Classe 2, Sênior 3, Escola Secundária Yizhuang No. 2, Zona de Desenvolvimento Econômico e Tecnológico do Distrito de Daxing, Pequim Desvantagens
:
Redundante (não recomendado)
第二种方案：两张表（班级表和学生表）
t_class 班级表
cno(pk) cname
101 北京大兴区经济技术开发区亦庄二中高三1班
102 北京大兴区经济技术开发区亦庄二中高三2班
t_student 学生表
sno(pk) sname classno(该字段添加外键约束fk)
1 zs1 101
2 zs2 101
3 zs3 102
4 zs4 102
5 zs5 102
Escreva a instrução de criação de tabela para a tabela acima:
O campo classno em t_student refere-se ao campo cno na tabela t_class.Neste momento, a tabela t_student é chamada de tabela filha. A tabela t_class é chamada de tabela pai.
Requisitos de sequência: (Adicione a tabela pai primeiro, exclua a tabela filho primeiro)
Ao excluir dados, exclua primeiro a tabela filho e, em seguida, exclua a tabela pai.
Ao adicionar dados, adicione primeiro a tabela pai e depois adicione a tabela filha.
Ao criar uma tabela, crie primeiro a tabela pai e depois crie a tabela filha.
Ao excluir uma tabela, exclua primeiro a tabela filha e depois a tabela pai.
drop table if exists t_student;
drop table if exists t_class;
create table t_class(
cno int,
cname varchar(255),
primary key(cno)
);
create table t_student(
sno int,
sname varchar(255),
classno int,
foreign key(classno) references t_class(cno)
);
insert into t_class values(101,'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
insert into t_class values(102,'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy');
insert into t_student values(1,'zs1',101);
insert into t_student values(2,'zs2',101);
insert into t_student values(3,'zs3',102);
insert into t_student values(4,'zs4',102);
insert into t_student values(5,'zs5',102);
insert into t_student values(6,'zs6',102);
select * from t_class;
select * from t_student;
insert into t_student values(7,'lisi',103); # ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`staff`.`t_student`, CONSTRAINT `t_student_ibfk_1` FOREIGN KEY (`classno`) REFERENCES `t_class` (`cno`))
As chaves estrangeiras podem ser NULL.
O campo referenciado não precisa necessariamente ser a chave primária, mas pelo menos possui uma restrição de exclusividade (singularidade). Geralmente, refere-se à chave primária.
Mecanismo de armazenamento (compreensão)
1. A declaração completa de criação de tabela é escrita assim
CREATE TABLE `t_x` (
`id` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
Nota: No MySQL, todos os identificadores podem ser colocados entre símbolos. É melhor não usar, não é universal.
Ao criar uma tabela, você pode especificar o mecanismo de armazenamento e o conjunto de caracteres.
O mecanismo de armazenamento padrão usado pelo mysql é o InnoDB.
O conjunto de caracteres padrão é UTF-8.
2. Qual é o seu mecanismo de armazenamento?
O mecanismo de armazenamento de nomes existe apenas no mysql. (Existe um mecanismo correspondente no Oracle, mas não é chamado de mecanismo de armazenamento. Não existe um nome especial no Oracle. É o método de armazenamento da tabela.) O mecanismo de armazenamento é o método de armazenamento da tabela
.
O MySQL suporta muitos mecanismos de armazenamento e cada mecanismo de armazenamento corresponde a um método de armazenamento diferente.
Cada mecanismo de armazenamento tem suas próprias vantagens e desvantagens, e você precisa escolher o mecanismo de armazenamento certo no momento certo.
3. Verifique os mecanismos de armazenamento atualmente suportados pelo MySQL?
show engines \G
Existem 9 mecanismos de armazenamento suportados pelo mysql8
4. Mecanismos de armazenamento comuns
Mecanismo de armazenamento MyISAM
Engine: MyISAM
Support: YES
Comment: MyISAM storage engine
Transactions: NO
XA: NO
Savepoints: NO
Mecanismos de armazenamento como MyISAM não suportam transações.
MyISAM é o mecanismo de armazenamento mais comumente usado para MySQL, mas esse mecanismo não é o padrão.
MyISAM utiliza três arquivos para organizar uma tabela:
xxx.frm (arquivo que armazena o formato)
xxx.MYD (arquivo que armazena os dados da tabela)
xxx.MYI (arquivo que armazena o índice da tabela)
Vantagens: Pode ser compactado , economizando espaço de armazenamento. E pode ser convertida em uma tabela somente leitura para melhorar a eficiência da recuperação.
Desvantagens: As transações não são suportadas.
Mecanismo de armazenamento InnoDB (mecanismo de armazenamento padrão, comumente usado)
Engine: InnoDB
Support: DEFAULT
Comment: Supports transactions, row-level locking, and foreign keys
Transactions: YES
XA: YES
Savepoints: YES
Vantagens: Suporta transações, bloqueios em nível de linha, chaves estrangeiras, etc. A segurança dos dados neste motor de armazenamento está garantida.
A estrutura da tabela é armazenada no arquivo xxx.frm e
os dados são armazenados em um espaço de tabela (conceito lógico), como o espaço de tabela, que não pode ser compactado ou convertido em autoleitura.
Este mecanismo de armazenamento InnoDB fornece um mecanismo de recuperação automática após uma falha no banco de dados MySQL.
InnoDB suporta exclusão e atualização em cascata.
Mecanismo de armazenamento de MEMÓRIA
Engine: MEMORY
Support: YES
Comment: Hash based, stored in memory, useful for temporary tables
Transactions: NO
XA: NO
Savepoints: NO
Desvantagens: As transações não são suportadas. Os dados serão perdidos após queda de energia. Porque todos os dados e índices são armazenados na memória.
Vantagens: A velocidade de consulta mais rápida.
ver (compreender)
Visualizar: observe os dados de diferentes ângulos. (Os dados na mesma tabela podem ser visualizados de diferentes ângulos)
Criar e excluir visualizações:
create view myview as select empno,ename from emp;
drop view myview
Nota: Somente instruções DQL podem ser criadas como objetos de visualização.
Adicionar, excluir, modificar e consultar visualizações afetará os dados originais da tabela. (Os dados da tabela original são afetados pela visualização, não a tabela original que é operada diretamente.)
As operações CRUD podem ser executadas na visualização.
Operações orientadas à visualização:
select * from myview;
+-------+--------+
| empno | ename |
+-------+--------+
| 7369 | SMITH |
| 7499 | ALLEN |
| 7521 | WARD |
| 7566 | JONES |
| 7654 | MARTIN |
| 7698 | BLAKE |
| 7782 | CLARK |
| 7788 | SCOTT |
| 7839 | KING |
| 7844 | TURNER |
| 7876 | ADAMS |
| 7900 | JAMES |
| 7902 | FORD |
| 7934 | MILLER |
+-------+--------+
create table emp_bak as select * from emp;
create view myview1 as select empno,ename,sal from emp_bak;
update myview1 set ename='hehe',sal=1 where empno=7369; # 通过视图修改原表数据
delete from myview1 where empno=7369; # 通过视图删除原表数据
Função de visualização: as visualizações podem ocultar os detalhes de implementação da tabela. Em sistemas com níveis de confidencialidade mais altos, o banco de dados fornece apenas visualizações relevantes para o mundo externo, e os programadores Java executam CRUD apenas em objetos de visualização.
Importação e exportação de dados de banco de dados (comandos DBA)
Exporte todo o banco de dados: execute na janela de comando do DOS
mysqldump 数据库>D:\数据库.sql -uroot -p密码
Exporte a tabela especificada na biblioteca especificada: execute na janela de comando do DOS
mysqldump 数据库 表名>D:\数据库.sql -uroot -p密码
Importar dados:
create database 数据库;
use 数据库;
source D:\数据库.sql
Transação
1. O que é uma transação?
Uma transação é uma unidade lógica de negócios completa e não pode ser dividida posteriormente.
Por exemplo: transferência de conta bancária, transferindo 10.000 da conta A para a conta B, requer a execução de dois extratos de atualização.
update t_act set balance=balance-1000 where actno='act-001';
update t_act set balance=balance+1000 where actno='act-002';
As duas instruções DML acima devem ser bem-sucedidas ou falhar ao mesmo tempo. Um sucesso e uma falha não são permitidos.
Para garantir que as duas instruções DML acima sejam bem-sucedidas ou falhem ao mesmo tempo, você precisa usar o "mecanismo de transação" do banco de dados.
2. As únicas declarações relacionadas às transações são: declarações DML. (inserir exclusão atualização)
Porque essas três instruções estão relacionadas aos "dados" na tabela do banco de dados.
As transações existem para garantir a integridade e segurança dos dados.
3. Supondo que todos os negócios possam ser concluídos usando uma instrução DML, ainda é necessário um mecanismo de transação?
Nenhuma transação é necessária.
Mas a situação real não é esta: normalmente uma coisa (transação [negócio]) requer que várias instruções DML sejam concluídas em conjunto.
4. Quais são as características da transação?
As transações incluem quatro características principais: ACID
A: Atomicidade: Uma transação é a menor unidade de trabalho e não pode ser dividida posteriormente.
C: Consistência: A transação deve garantir que múltiplas instruções DML sejam bem-sucedidas ou falhem ao mesmo tempo.
I: Isolamento: Existe isolamento entre a transação A e a transação B.
D: Persistência: Os dados finais devem ser persistidos no arquivo do disco rígido antes que a transação termine com sucesso.
5. Em relação ao isolamento entre transações
. Existem níveis de isolamento para isolamento de transações. Teoricamente, existem 4 níveis de isolamento:
Nível 1: leitura não confirmada (leitura não confirmada).
A transação da outra parte ainda não foi enviada. Nossa transação atual pode ler o dados enviados não confirmados de outra parte.
Existe um fenômeno de leitura suja quando a leitura não é confirmada: significa que dados sujos foram lidos.
Nível 2: Leitura confirmada (leitura confirmada)
Os dados após o envio da transação da outra parte podem ser lidos por nós.
Este nível de isolamento resolve o problema: o fenômeno da leitura suja desapareceu.
O problema com a leitura dos dados enviados é que eles não podem ser lidos repetidamente.
Nível 3: Leitura repetível (leitura repetível)
Este nível de isolamento resolve o problema de leitura não repetível.
O problema com esse nível de isolamento é que a leitura dos dados é fantasma.
O quarto nível: leitura serializada/leitura serializável (serializável)
resolve todos os problemas.
baixa eficiencia. Requer enfileiramento de transações.
O nível de isolamento padrão do banco de dados Oracle é: leitura confirmada.
O nível de isolamento padrão do banco de dados MySQL é: leitura repetível.
6. Transação de demonstração
A transação MySQL é automaticamente confirmada por padrão.
(O que é envio automático? Contanto que qualquer instrução DML seja executada, ela será enviada uma vez.) Como desativar o envio automático? iniciar transação;
Se você quiser salvar o ponto, ele retornará ao ponto de salvamento.
Criar a tabela:
drop table if exists t_user;
create table t_user(
id int primary key auto_increment,
username varchar(255)
);
Demonstração: As transações no mysql são enviadas automaticamente.Enquanto um DML for executado, ele será enviado uma vez.
mysql> insert into t_user(username) values('zs');
Query OK, 1 row affected (0.01 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
+----+----------+
1 row in set (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
+----+----------+
1 row in set (0.00 sec)
Demonstração: use iniciar transação para desativar transações de confirmação automática.
reversão
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into t_user(username) values('lisi');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t_user(username) values('wangwu');
Query OK, 1 row affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 2 | lisi |
| 3 | wangwu |
+----+----------+
3 rows in set (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
+----+----------+
1 row in set (0.00 sec)
enviar
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into t_user(username) values('wangwu');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t_user(username) values('reos');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t_user(username) values('jack');
Query OK, 1 row affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 4 | wangwu |
| 5 | reos |
| 6 | jack |
+----+----------+
4 rows in set (0.00 sec)
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 4 | wangwu |
| 5 | reos |
| 6 | jack |
+----+----------+
4 rows in set (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 4 | wangwu |
| 5 | reos |
| 6 | jack |
+----+----------+
4 rows in set (0.00 sec)
índice
1. O que é um índice? Qual é a utilidade?
O índice equivale ao índice de um livro, através do qual os recursos correspondentes podem ser encontrados rapidamente.
Em termos de bancos de dados, existem dois métodos de recuperação ao consultar uma tabela:
o primeiro método: varredura completa da tabela;
o segundo método: recuperação baseada em índice (muito eficiente).Por
que os índices podem melhorar a eficiência da recuperação?
Na verdade, o princípio mais fundamental é reduzir o escopo da digitalização.
Embora os índices possam melhorar a eficiência da recuperação, os índices não podem ser adicionados arbitrariamente porque os índices também são objetos no banco de dados e exigem manutenção constante do banco de dados. Existem custos de manutenção. Por exemplo, se os dados da tabela são modificados com frequência, não é adequado adicionar um índice, porque uma vez modificados os dados, o índice precisa ser reordenado e mantido.
Adicionar um índice é adicionar um índice a um determinado campo ou a alguns campos.
select ename,sal from emp where ename='SMITH';
Quando nenhum índice é adicionado ao campo ename, a instrução SQL acima realizará uma varredura completa da tabela e verificará todos os valores no campo ename.
Quando um índice é adicionado ao campo ename, a instrução SQL acima será verificada de acordo com o índice para localizá-la rapidamente.
2. Como criar um objeto de índice? Como deletar objetos de índice?
Crie um objeto de índice:
create index 索引名称 on 表名(字段名);
Excluir objetos de índice:
drop index 索引名称 on 表名；
3. Quando você deve considerar adicionar índices aos campos? (quais condições são atendidas)
- Grande quantidade de dados (de acordo com as necessidades do cliente e ambiente online)
- Existem muito poucas operações DML neste campo (porque o campo precisa ser modificado e o índice também precisa ser mantido)
- Este campo geralmente aparece na cláusula where (campo frequentemente consultado com base em)
4. Observação: os índices serão adicionados automaticamente às chaves primárias e aos campos com restrições exclusivas.
A consulta baseada na chave primária é mais eficiente. Tente pesquisar com base na chave primária.
5. Verifique o plano de execução da instrução sql (explicar),
apenas o MySQL o possui.
mysql> explain select ename,sal from emp where sal = 5000;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
| 1 | SIMPLE | emp | NULL | ALL | NULL | NULL | NULL | NULL | 14 | 10.00 | Using where |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
Adicione um índice ao campo salário sal:
create index emp_sal_index on emp(sal);
mysql> explain select ename,sal from emp where sal = 5000;
+----+-------------+-------+------------+------+---------------+---------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+-------+------------+------+---------------+---------------+---------+-------+------+----------+-------+
| 1 | SIMPLE | emp | NULL | ref | emp_sal_index | emp_sal_index | 9 | const | 1 | 100.00 | NULL |
+----+-------------+-------+------------+------+---------------+---------------+---------+-------+------+----------+-------+
6. A estrutura de dados usada na parte inferior do índice é: B + Árvore
7. Como o índice é implementado?
O escopo da varredura é reduzido por meio da árvore B e o índice subjacente é classificado e particionado. O índice carregará o "endereço físico" dos dados na tabela. Finalmente, após os dados serem recuperados por meio do índice, o endereço físico associado
é obtido, e o endereço físico é usado para localizar os dados na tabela. Dados, a eficiência é a mais alta.
select ename from emp where ename='SMITH';
通过索引转换为：
select ename from emp where 物理地址=0x3;
8. Classificação do índice?
Índice único: adiciona um índice a um único campo.
Índice composto: adiciona um índice a vários campos.
Índice de chave primária: um índice é adicionado automaticamente à chave primária.
Índice exclusivo: um índice é adicionado automaticamente a campos com restrições exclusivas.
9. Quando o índice expira?
Ao realizar uma consulta difusa, o primeiro caractere curinga é% e o índice é inválido neste momento.
select ename from emp where ename like '%A%';
Três especificações principais de design para bancos de dados (conteúdo principal, frequentemente questionado em entrevistas)
1. O que é um paradigma de design?
A base para projetar tabelas é que tabelas projetadas de acordo com esses três paradigmas não terão redundância de dados.
2. Quais são os três paradigmas?
Primeira forma normal: qualquer tabela deve ter uma chave primária e cada campo deve ser atômico e irredutível.
Segunda forma normal: Com base na primeira forma normal, todos os campos de chave não primária são completamente dependentes da chave primária e não podem produzir dependências parciais.
Muitos para muitos, três tabelas, duas chaves estrangeiras na tabela relacional.
t_student学生表
sno(pk) sname
1 张三
2 李四
3 王五
t_teacher讲师表
tno tname
1 王老师
2 张老师
3 李老师
t_student_teacher_relation 学生讲师关系表
id(pk) sno(fk) tno(fk)
1 1 3
2 1 1
3 2 2
4 2 3
5 3 1
6 3 3
Terceira forma normal: Com base na segunda forma normal, todos os campos de chave não primária dependem diretamente da chave primária e não podem produzir dependências transitivas.
Um para muitos, duas tabelas, muitas tabelas mais chaves estrangeiras.
班级t_class
cno(pk) cname
1 a
2 b
3 c
4 d
学生t_student
sno(pk) sname classnoo(fk)
101 张1 1
102 张2 1
103 张3 2
104 张4 2
105 张5 2
Lembrete (você pode dizer isso durante a entrevista): No desenvolvimento real, o foco está em atender às necessidades do cliente e, às vezes, a redundância é trocada pela velocidade de execução.
3. Como projetar individualmente?
Existem duas opções para design um-para-um: compartilhamento de chave primária
t_user_login tabela de login do usuário
id(pk) username password
1 zs 123
2 ls 456
tabela de detalhes do usuário t_user_detail
id(pk) realname tel
1 张三 111111111
2 李四 111132321
Existem duas opções para design um-para-um: chave estrangeira exclusiva
t_user_login tabela de login do usuário
id(pk) username password
1 zs 123
2 ls 456
tabela de detalhes do usuário t_user_detail
id(pk) realname tel userid(fk+unique)
1 张三 111111111 2
2 李四 111132321 1
Ordem de execução SQL
(1) FROM [left_table] 选择表
(2) ON <join_condition> 链接条件
(3) <join_type> JOIN <right_table> 链接
(4) WHERE <where_condition> 条件过滤
(5) GROUP BY <group_by_list> 分组
(6) AGG_FUNC(column or expression),... 聚合/分组
(7) HAVING <having_condition> 分组过滤
(8) SELECT (9) DISTINCT column,... 选择字段、去重
(9) ORDER BY <order_by_list> 排序
(10) LIMIT count OFFSET count; 分页
Funções comuns
O banco de dados MySQL fornece funções ricas, semelhantes aos métodos em Java.
função inferior()
Este campo é todo convertido para letras minúsculas
INFERIOR (Nome do campo Str)
select lower(ename) from emp;
função superior()
Este campo é convertido para todas as letras maiúsculas
UPPER(Str nome do campo)
função comprimento()
Comprimento do campo de consulta, uma letra conta como um caractere e um caractere chinês conta como três caracteres
COMPRIMENTO(Str nome do campo)
função concat()
Emendando cordas
CONCAT (nome do campo Str, conteúdo de emenda Str, conteúdo de emenda Str...)
função substr()
String de interceptação
SUBSTR (nome do campo, posição inicial de interceptação, comprimento total de interceptação)
**Observação:**Os índices começam em 1
função substituir()
Substituição
REPLACE(Str nome do campo, from_str conteúdo a ser substituído, to_str novo conteúdo)
função ifnull()
Determine se é nulo. Se for nulo, substitua-o por 0 ou 1, etc.
IFNULL(nome do campo expr1, novo conteúdo expr2 a ser substituído)
**Observação: **NULL aparece no banco de dados ao realizar cálculos, não participa do cálculo e sempre será NULL.
função round()
Decimais, arredondados
ROUND (nome do campo)
função ceil()
Decimais, arredondando, se houver decimais, retire o número inteiro e adicione um
CEIL (nome do campo)
função piso()
Decimais, arredondar para baixo, se houver decimais, remover os decimais
FLOOR (nome do campo)
função agora()
Consulte a hora atual, ano, mês, dia, hora, minuto e segundo
AGORA()
função curdate()
Ano, mês e dia
CORDADO()
função curtime()
Horas, minutos e segundos
CORTIME()
função ano()
Anos
ANO(data data) / ANO(string de data escreve uma data)
função mês()
mês
MÊS(data data) / MÊS(dados de gravação de string de data)
função dia()
dia
DIA(data data) / DIA(dados de data de gravação de string de data)
função hora()
tempo
HORA(data data) / HORA(dados de gravação de string de data)
função minuto()
pontos
MINUTO(data data) / MINUTO(data string escrever dados de data)
função segundo()
segundos
SEGUNDO (data data) / SEGUNDO (dados de gravação de string de data)
função timestampdiff()
Calcule a diferença horária entre duas datas, que pode ser ano, mês, dia, hora, minuto, segundo, dia da semana,
timestampdiff (tipo de intervalo, data anterior, próxima data)
personagem de fuga
' Como um símbolo de instrução SQL, se um único apóstrofo aparecer no conteúdo, ele ficará confuso. Basta escapar dele.
Método 1: Use um \ para escapar para um caractere normal
Método 2: Use " " fora
select
ename,
lower(ename),
upper(ename),
length(ename),
concat(ename,'hello',100),
substr(ename,2),
substr(ename,1,3),
replace(ename,'S','666'),
ifnull(comm,0),
round(sal),
ceil(sal),
floor(sal),
now(),
curdate(),
curtime(),
year('1999-02-12'),month(now()),day(now()),hour(now()),minute(curtime()),second('12:22:1')
from
emp;
Otimização de SQL
1. Insira otimização de dados
2. Otimização de chave primária:
A divisão de páginas pode ocorrer quando as chaves primárias são inseridas fora de ordem.
3. ordenar por otimização
4. agrupar por otimização
5. Limite a otimização
6. Otimização de contagem
7. Otimização de atualização:
tente atualizar os dados com base na chave primária/campo de índice
Resumir
- Tente usar nomes de campos em vez de *
- Ao projetar tabelas, é melhor usar varchar em vez de char como tipo de campo.
- Para o valor no campo, é melhor usar números em vez de strings
- Tente tornar as condições de filtragem o mais detalhadas possível. Você pode usar e mas não ou.
- Design de índice, até 5 índices, não muitos
- Consulta difusa, tente determinar o elemento inicial para tornar o índice eficaz
- O banco de dados não possui requisitos rígidos para números. O índice name=123 é inválido e o índice name='123' é válido.
- É melhor excluir índices inúteis imediatamente
Ao usar not int, lembre-se de excluir NULL entre parênteses a seguir.