CRUD é a primeira letra de várias instruções sql que são adicionadas, excluídas, modificadas e verificadas, ou seja, criar (criar), consultar (recuperar), atualizar (atualizar) e excluir (excluir).

2. Aumente os dados

2.1 Criar dados

Para criar um banco de dados, a sintaxe é: create database nome do banco de dados; por exemplo, para criar um banco de dados chamado teste:

mysql> create database test;
Query OK, 1 row affected (0.00 sec)

Quando o campo Consulta Ok aparecer na última linha, significa que o banco de dados foi criado com sucesso.

Para criar uma tabela, a sintaxe é: criar tabela nome da tabela; por exemplo, para criar uma tabela chamada aluno:

mysql> use test;
Database changed
mysql> create table student(
    -> id int,
    -> name varchar(20),
    -> price decimal
    -> );
Query OK, 0 rows affected (0.02 sec)

Quando criamos uma tabela, devemos primeiro usar um banco de dados. Depois que a tabela for criada com sucesso, a última linha da instrução exibirá a instrução Query Ok..

2.2 Inserir dados

2.2.1 Inserção de linha única

Quando criamos uma tabela, não há informações na tabela, então temos que inserir alguns dados para armazenar. Usamos inserir valores no nome da tabela (campo 1, campo 2,....); para inserir alguns dados, observe que os dados inseridos devem ter a mesma estrutura da tabela. Inserimos uma linha de informações na tabela do aluno:

mysql> insert into student values(1,'张三',20);
ERROR 1366 (HY000): Incorrect string value: '\xD5\xC5\xC8\xFD' for column 'name' at row 1

Podemos ver que há um ERROR (erro). Isso significa que a string Zhang San não introduziu o formato utf-8, portanto, ao criarmos o banco de dados, devemos primeiro declarar o formato utf8 para que a adição de dados não cause erros, conforme mostrado abaixo:

mysql> create database test charset utf8;
Query OK, 1 row affected (0.00 sec)

Desta forma, ao criarmos o banco de dados, também declaramos que o conjunto de caracteres é do tipo utf-8, para não cometermos erros na hora de criar tabelas e adicionar novos dados. Declare a sintaxe do conjunto de caracteres: tipo de conjunto de caracteres charset .

mysql> use test;
Database changed
mysql> create table student(
    -> id int,
    -> name varchar(20),
    -> price decimal
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> insert into student values(1,'张三',20);
Query OK, 1 row affected (0.00 sec)

Podemos ver que a última linha de dados é inserida, solicitando Consulta OK, esta é uma operação de inserção de linha única, vamos ver a inserção de várias linhas.

2.2.2 Inserção multilinha

A sintaxe de inserção de várias linhas é: inserir no nome da tabela (tipo 1, tipo 2, tipo 3,...) valores (campo 1, campo 2, campo 3,...), (campo 1, campo 2 , campo 3, ...);

mysql> insert into student(id,name,price) values
    -> (2,'李四',24),
    -> (3,'王五',30);
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

O código acima adiciona mais duas linhas de dados ao aluno, então agora há três linhas de dados na tabela aluno. Podemos usar selecionar * do aluno; consulta de coluna completa para visualizar a estrutura da tabela do aluno.

mysql> select * from student;
+------+------+-------+
| id   | name | price |
+------+------+-------+
|    1 | 张三 |    20 |
|    2 | 李四 |    24 |
|    3 | 王五 |    30 |
+------+------+-------+
3 rows in set (0.00 sec)

Obviamente, adicionei os três campos de id, nome e preço à inserção de várias linhas acima. Você também pode adicionar qualquer número desses três campos arbitrariamente, como adicionar apenas os dois campos de id e nome e assim por diante.

3. Encontre dados

3.1 Consulta de coluna completa

Consulta de coluna completa, ou seja, para consultar os dados em toda a tabela. O formato da sintaxe é: selecione * do nome da tabela; onde * é um curinga que representa todos os dados. Por exemplo, para consultar todos os dados na tabela do aluno acima:

mysql> use test;
Database changed
mysql> select * from student;
+------+------+-------+
| id   | name | price |
+------+------+-------+
|    1 | 张三 |    20 |
|    2 | 李四 |    24 |
|    3 | 王五 |    30 |
+------+------+-------+
3 rows in set (0.00 sec)

Podemos ver que todos os dados são exibidos, que é a consulta de coluna completa. Mas observe que, em nosso processo de desenvolvimento real, o símbolo * não deve ser usado arbitrariamente. Quando usamos * para consultar uma tabela de dados enorme ou outros tipos de dados, toda a memória é ocupada e o banco de dados não atualiza ou adiciona dados normalmente, o que é muito perigoso! Portanto, podemos experimentá-lo em nosso próprio computador, porque nosso banco de dados é pequeno e há uma grande probabilidade de não haver risco de perda de dados.

3.2 Consulta de coluna especificada

Acima, sabemos que o número * é muito perigoso, por isso é mais seguro consultar a coluna especificada. Podemos consultar diretamente os dados de uma determinada coluna, para que o uso de memória seja muito baixo. A sintaxe de consulta da coluna especificada é: selecione campo 1, campo 2 do nome da tabela; se eu quiser encontrar as duas colunas de dados na tabela do aluno, id e nome:

mysql> select id,name from student;
+------+------+
| id   | name |
+------+------+
|    1 | 张三 |
|    2 | 李四 |
|    3 | 王五 |
+------+------+
3 rows in set (0.00 sec)

Podemos ver que a consulta da coluna especificada é muito "humanizada". Podemos consultar os dados na coluna que queremos consultar, de modo que o uso de memória será muito baixo. Este método de consulta é recomendado.

3.3 O campo de consulta é uma expressão

Primeiro, criamos uma tabela de notas e inserimos duas linhas de dados:

mysql> create table grades(
    -> chinese int,
    -> math int,
    -> english int);
Query OK, 0 rows affected (0.03 sec)
mysql> insert into grades(chinese,math,english) values
    -> (78,98,59),
    -> (76,99,35);
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

O acima cria uma tabela de pontuação muito bem, e esta tabela tem duas linhas de dados. Em seguida, a criação de tabelas e a inserção de informações da tabela foram explicadas acima, e parceiros não qualificados podem dar uma olhada.

3.3.1 Expressão não contém campos

Quando a expressão não contém campos, significa que qualquer informação nesta expressão não é nenhum campo da tabela. Por exemplo, consulte um campo chamado 10 no subscrito a seguir:

mysql> select chinese,math,english,10 from grades;
+---------+------+---------+----+
| chinese | math | english | 10 |
+---------+------+---------+----+
|      78 |   98 |      59 | 10 |
|      76 |   99 |      35 | 10 |
+---------+------+---------+----+
2 rows in set (0.00 sec)

Podemos ver que o número de colunas nesta expressão é 10. Essa consulta é uma consulta cuja expressão não contém campos. Observe que os campos aqui são os nomes de coluna de cada coluna na tabela.

3.3.2 Uma expressão contém um campo

Quando a expressão contém um campo, normalmente utilizamos esta operação quando queremos alterar os dados de uma determinada coluna da tabela. Por exemplo, quero aumentar a pontuação de inglês de todos na tabela de notas em 10 pontos:

mysql> select chinese,math,english+10 from grades;
+---------+------+------------+
| chinese | math | english+10 |
+---------+------+------------+
|      78 |   98 |         69 |
|      76 |   99 |         45 |
+---------+------+------------+
2 rows in set (0.00 sec)

3.3.3 A expressão contém vários campos

A expressão contém vários campos e geralmente usamos esse método de consulta quando queremos somar todos os dados em uma tabela. Se eu solicitar a soma de todos os dados da tabela de notas:

mysql> select chinese,math,english,chinese+math+english from grades;
+---------+------+---------+----------------------+
| chinese | math | english | chinese+math+english |
+---------+------+---------+----------------------+
|      78 |   98 |      59 |                  235 |
|      76 |   99 |      35 |                  210 |
+---------+------+---------+----------------------+
2 rows in set (0.00 sec)

Como podemos ver, a única desvantagem da conveniência de tal consulta é que os nomes das colunas são muito longos. Portanto, temos outra instrução SQL que pode criar um alias para esse longo nome de coluna para simplificá-lo. Para detalhes, veja abaixo:

Aliases de 3.4

A sintaxe que usamos para aliasing é expressão ou nome da coluna como alias; por exemplo, eu alias o extenso chinês+matemática+inglês acima para somar:

mysql> select chinese,math,english,chinese+math+english as sum from grades;
+---------+------+---------+------+
| chinese | math | english | sum  |
+---------+------+---------+------+
|      78 |   98 |      59 |  235 |
|      76 |   99 |      35 |  210 |
+---------+------+---------+------+
2 rows in set (0.00 sec)

Claro que também é possível criar um alias para uma única coluna:

mysql> select chinese as '中文' from grades;
+------+
| 中文 |
+------+
|   78 |
|   76 |
+------+
2 rows in set (0.00 sec)

Desta forma, não será muito complicado olhar para alguns campos quando consultamos dados.Esta é a operação de aliasing. Observe que o as pode ser omitido, mas é recomendável adicioná-lo para facilitar a leitura do código!

3.5distinto (desduplicação)

Crie uma tabela de alunos:

mysql> create table students(
    -> id int,
    -> name varchar(20),
    -> chinese int,
    -> math int,
    -> english int);
Query OK, 0 rows affected (0.02 sec)

Insira quatro linhas de dados:

mysql>  insert into students(id,name,chinese,math,english) values
    -> (1,'孙悟空',69,89,47),
    -> (2,'沙悟净',77,99,60),
    -> (3,'猪八戒',80,88,50),
    -> (4,'白龙马',69,77,88);
Query OK, 4 rows affected (0.01 sec)
Records: 4  Duplicates: 0  Warnings: 0

Descobrimos que as pontuações chinesas de Sun Wukong e Bailongma são as mesmas. Quando desejo exibir as pontuações chinesas e cada pontuação é diferente, posso usar a distinção para desduplicar:

mysql> select distinct chinese from students;
+---------+
| chinese |
+---------+
|      69 |
|      77 |
|      80 |
+---------+
3 rows in set (0.01 sec)

Podemos ver que 69 é exibido apenas uma vez, que é a função distinta na tabela: remover dados duplicados. Deve-se observar que a distinção só remove os dados duplicados quando os exibimos, e os dados desduplicados no banco de dados real não foram alterados!

3.6 ordenar por (classificação)

3.6.1 Um campo é classificado por padrão

Usamos a tabela de alunos para operar. Por exemplo, quero classificar por padrão de acordo com as pontuações em inglês:

mysql> select id,name,chinese,math,english from students order by english;
+------+--------+---------+------+---------+
| id   | name   | chinese | math | english |
+------+--------+---------+------+---------+
|    1 | 孙悟空 |      69 |   89 |      47 |
|    3 | 猪八戒 |      80 |   88 |      50 |
|    2 | 沙悟净 |      77 |   97 |      60 |
|    4 | 白龙马 |      69 |   77 |      88 |
+------+--------+---------+------+---------+
4 rows in set (0.00 sec)

Por observação, descobrimos que a classificação padrão é classificada em ordem crescente. Em seguida, a sintaxe de classificação padrão é: ordem por nome de campo; Claro, você também pode adicionar o campo asc para enfatizar que sua classificação está em ordem crescente, o que melhora a legibilidade do código.

3.6.2 Classificar um campo em ordem decrescente

Por exemplo, classifique de acordo com a ordem decrescente das pontuações em inglês:

mysql> select id,name,chinese,math,english from students order by english desc;
+------+--------+---------+------+---------+
| id   | name   | chinese | math | english |
+------+--------+---------+------+---------+
|    4 | 白龙马 |      69 |   77 |      88 |
|    2 | 沙悟净 |      77 |   97 |      60 |
|    3 | 猪八戒 |      80 |   88 |      50 |
|    1 | 孙悟空 |      69 |   89 |      47 |
+------+--------+---------+------+---------+
4 rows in set (0.00 sec)

Observa-se que se quisermos classificar em ordem decrescente, basta adicionar a palavra-chave desc após o nome do campo, então a sintaxe de classificação decrescente é: order by field name desc;

3.6.3 Classificando usando expressões e aliases

Use expressões para consultar, e a soma das três pontuações além do número de palavras de consulta é classificada em ordem decrescente:

mysql> select id,name,chinese + math + english as sum from students order by chinese + math + english desc;
+------+--------+------+
| id   | name   | sum  |
+------+--------+------+
|    2 | 沙悟净 |  234 |
|    4 | 白龙马 |  234 |
|    3 | 猪八戒 |  218 |
|    1 | 孙悟空 |  205 |
+------+--------+------+
4 rows in set (0.00 sec)

Use um alias para consultar e a soma das três pontuações além do número de palavras de consulta será classificada em ordem decrescente:

mysql>  select id,name,chinese + math + english as sum from students order by sum desc;
+------+--------+------+
| id   | name   | sum  |
+------+--------+------+
|    2 | 沙悟净 |  234 |
|    4 | 白龙马 |  234 |
|    3 | 猪八戒 |  218 |
|    1 | 孙悟空 |  205 |
+------+--------+------+
4 rows in set (0.00 sec)

Descobrimos que os resultados das duas consultas acima são os mesmos, portanto, se você tiver um tipo de operação no futuro, poderá usar qualquer um deles para consultar.

3.6.4 Classificando vários campos

Por exemplo, consulte em ordem decrescente de chinês e ordem crescente de matemática:

mysql> select id,name,chinese,math,english from students order by chinese desc,math;
+------+--------+---------+------+---------+
| id   | name   | chinese | math | english |
+------+--------+---------+------+---------+
|    3 | 猪八戒 |      80 |   88 |      50 |
|    2 | 沙悟净 |      77 |   97 |      60 |
|    4 | 白龙马 |      69 |   77 |      88 |
|    1 | 孙悟空 |      69 |   89 |      47 |
+------+--------+---------+------+---------+
4 rows in set (0.00 sec)

Este tipo de operação é adequado para classificação mista, funções específicas e operações específicas. Todos escolhem sua própria instrução sql de acordo com suas próprias necessidades.

3.7 onde (consulta de condição)

A instrução utilizada na consulta condicional é where , e seu formato gramatical é: select field 1, field 2,... where query condition;

3.7.1 Operadores de Comparação

operador	ilustrar
>,>=,<,<=	maior que, maior que ou igual a, menor que, menor que ou igual a
=	igual, NULL não é seguro, por exemplo NULL = NULL resulta em NULL
<=>	igual, NULL seguro, por exemplo NULL <=> NULL avalia como TRUE(1)
!=,<>	não igual a
ENTRE .. ADN ..	Entre .. e .., frente fechada e traseira fechada
EM()	existir
É NULO	está vazia
NÃO É NULO	não está vazio
COMO	Consulta difusa, quando LIKE é seguido de um sinal %, representa 0 ou mais campos, quando LIKE é seguido de _, os campos são representados de acordo com o número de _.

Encontre alunos que falharam em inglês:

mysql> select id,name,chinese,math,english from students where english<60;
+------+--------+---------+------+---------+
| id   | name   | chinese | math | english |
+------+--------+---------+------+---------+
|    1 | 孙悟空 |      69 |   89 |      47 |
|    3 | 猪八戒 |      80 |   88 |      50 |
+------+--------+---------+------+---------+
2 rows in set (0.00 sec)

Encontre alunos com notas de inglês entre 60 e 90:

mysql> select id,name from students where english between 60 and 90;
+------+--------+
| id   | name   |
+------+--------+
|    2 | 沙悟净 |
|    4 | 白龙马 |
+------+--------+
2 rows in set (0.01 sec)

Encontrar alunos com o sobrenome Sol:

mysql> select id,name from students where name like '孙%';
+------+--------+
| id   | name   |
+------+--------+
|    1 | 孙悟空 |
+------+--------+
1 row in set (0.00 sec)

Encontre os alunos cujo sobrenome é Sun e cujo comprimento do nome é 2:

mysql> select id,name from students where name like'孙_';
Empty set (0.00 sec)

No código acima, ele finalmente mostra que Vazio significa que não há alunos correspondentes a esse campo. Então, muitas operações na tabela acima são semelhantes, então o blogueiro dará três exemplos aqui, e você mesmo poderá testar na tabela.

3.7.2 Operadores lógicos

operador	ilustrar
E	Várias condições devem ser TRUE para que o resultado seja TRUE
OU	Se alguma condição for VERDADEIRA, o resultado será VERDADEIRO
NÃO	A condição é VERDADEIRA, o resultado é FALSO

Consulte os alunos cuja pontuação em chinês>=80 e pontuação em inglês>=80:

mysql> select id,name from students where chinese>= 80 and math>=80;
+------+--------+
| id   | name   |
+------+--------+
|    3 | 猪八戒 |
+------+--------+
1 row in set (0.00 sec)

Consulta para alunos cuja pontuação em chinês é >80 ou pontuação em inglês é <60:

mysql> select id,name from students where chinese>80 or english<60;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 孙悟空 |
|    3 | 猪八戒 |
+------+--------+
2 rows in set (0.00 sec)

Consultar alunos que reprovaram em inglês:

mysql> select id,name from students where not english>=60;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 孙悟空 |
|    3 | 猪八戒 |
+------+--------+
2 rows in set (0.00 sec)

Podemos ver que a consulta por operadores lógicos é consistente com a expressão de operadores como && e || em C e Java, exceto que o inglês é usado no MySQL.

3.8 limite (paginação)

Consulta de paginação é consultar os dados correspondentes de acordo com o regulamento, este regulamento é determinado de acordo com suas necessidades, ou seja, qual página ou linhas de dados você deseja consultar. Seu formato gramatical é adicionar uma declaração de limite com base na consulta de coluna especificada e existem três formatos:

-- O subscrito inicial é 0

-- A partir de 0, filtrar n resultados

SELECT ... FROM nome_da_tabela [WHERE ...] [ORDER BY ...] LIMIT n;

-- A partir de s, filtrar n resultados

SELECT ... FROM nome_da_tabela [WHERE ...] [ORDER BY ...] LIMIT s, n;

-- A partir de s, filtrar n resultados, que é mais específico do que o segundo uso, é recomendável usar

SELECT ... FROM nome_da_tabela [WHERE ...] [ORDER BY ...] LIMIT n OFFSET s;

Consultar as informações de id e nome nos três primeiros registros da tabela de alunos, e posso adicionar o limite 3 no final:

mysql> select id,name from students limit 3;
+------+--------+
| id   | name   |
+------+--------+
|    1 | 孙悟空 |
|    2 | 沙悟净 |
|    3 | 猪八戒 |
+------+--------+
3 rows in set (0.00 sec)

Você também pode especificar qual linha iniciar a consulta. Por exemplo, eu quero consultar a partir da terceira linha da tabela de alunos e consultar duas linhas de registros:

mysql> select id,name from students limit 2,2;
+------+--------+
| id   | name   |
+------+--------+
|    3 | 猪八戒 |
|    4 | 白龙马 |
+------+--------+
2 rows in set (0.00 sec)

Vemos que o efeito que eu quero foi alcançado, então a sintaxe da consulta de paginação para especificar o número de linhas é: limit n,s; onde s é a posição inicial e n é o número de linhas . Mas este método não é rigoroso o suficiente, o correto deve ser limit n offset s; onde s também é a posição inicial e n é o número de linhas . Observe que o número de linhas é incrementado automaticamente com base em 0 para o primeiro dado, o que é consistente com o subscrito da matriz.

4. Modifique os dados

Para modificar dados, a instrução sql usada é update . Sua sintaxe é: atualizar nome da tabela definir modificar valor where condição; por exemplo, defina a pontuação em inglês de Zhu Bajie na tabela de alunos como 0:

mysql> update students set english = 0 where name = '猪八戒';
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Vamos verificar todas as informações da tabela alunos através da consulta da coluna completa:

Podemos ver que a pontuação em inglês de Zhu Bajie foi definida como 0. Claro, também podemos modificar os dados por meio de expressões. Por exemplo, a pontuação em inglês de Zhu Bajie é aumentada em 100 por meio da expressão:

mysql> update students set english = english+100 where name = '猪八戒';
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Podemos ver que a modificação por meio de expressões também é possível, mas a única coisa a prestar atenção é. Se quisermos aumentar ou diminuir um dado, devemos escrevê-lo como data = data + value, não como data + = value, que é o mesmo que chinês = chinês + 100 no código acima;

5. Excluir dados

A instrução sql usada para excluir dados é delete e seu formato gramatical é: delete from table name where delete target; por exemplo, delete the white dragon horse information in the Students table:

mysql> delete from students where name = '白龙马';
Query OK, 1 row affected (0.00 sec)

Exiba a tabela dos alunos:

Podemos ver que restam três registros na tabela de alunos. Claro, também podemos excluir as informações de toda a tabela por meio de delete:

Query OK, 3 rows affected (0.01 sec)

mysql> select * from students;
Empty set (0.00 sec)

Após excluir todas as informações da tabela de alunos, ela é exibida como vazia quando usamos a consulta de coluna completa. Note que delete apenas apaga todos os dados da tabela sem deletar a tabela, e a operação drop é mais perigosa, apaga toda a tabela e todos os dados da tabela. Portanto, devemos prestar atenção ao excluir a operação do banco de dados!

O conteúdo do artigo é relativamente rico e você deve praticar mais depois de descer. Somente implementando essas operações podemos compreender melhor esses pontos de conhecimento.Além disso, você também pode testar os exemplos que não são mencionados nos operadores de comparação na consulta condicional where. Este post do blog está aqui, obrigado pela paciência na leitura, se você ganhar alguma coisa, preste atenção.

Banco de dados MySQL, explicação detalhada de adição, exclusão, modificação e verificação de tabelas

1.CRUD