SQL Notes (1) - MySQL para criar um banco de dados (coleção eat ashes version)

Language 2023-08-09 00:06:30 views: null

Este artigo registra detalhadamente o processo de criação de um banco de dados MySQL, não apenas as etapas de construção, mas também os pontos de conhecimento envolvidos em cada etapa. Geralmente, existem duas maneiras de criar um banco de dados, uma por meio de comandos e a outra por meio de ferramentas de gerenciamento de banco de dados. Este artigo registra principalmente a criação por meio de comandos;

Estudos subsequentes também são baseados nessa base de dados;

Cenas

Criação de uma base de dados de gestão do desempenho dos estudantes universitários;

Contém quatro tabelas: tabela do aluno, tabela do currículo, tabela de notas e tabela do professor:

Ao mesmo tempo, insira dados de teste para cada tabela;

As tabelas precisam ser associadas através de chaves estrangeiras;

Criado por comando

Aprender a usar comandos para criar um banco de dados MySQL tem as seguintes vantagens:

  1. Obtenha uma melhor compreensão de como o banco de dados MySQL funciona e seus componentes internos. Ao usar a linha de comando para operar o banco de dados, você pode ter uma compreensão mais clara da implementação subjacente e da interação do banco de dados, o que é muito útil para um aprendizado aprofundado do banco de dados MySQL.
  2. Pode melhorar a eficiência em alguns cenários. No caso de criar, modificar ou gerenciar bancos de dados MySQL em lotes, usar a linha de comando pode concluir tarefas com mais rapidez e flexibilidade do que aplicativos de desktop e melhorar a eficiência do trabalho.
  3. Pode entender melhor a política de segurança do banco de dados MySQL. Ao usar a linha de comando para criar um banco de dados MySQL, você precisa definir o nome de usuário e a senha do banco de dados e outras informações, o que pode nos ajudar a entender melhor a estratégia de controle de acesso ao banco de dados e garantir a segurança dos dados.
  4. O método de linha de comando é mais conveniente e aplicável. Em diferentes sistemas operacionais e ambientes, o método de linha de comando é comum, possuindo certa aplicabilidade e praticidade, o que aumenta muito a portabilidade e facilidade de uso do banco de dados MySQL.

O seguinte é um processo completo: a estrutura é comando + explicação + efeito de operação

Conecte-se ao banco de dados

mysql -u root -p
  • mysqlÉ uma ferramenta de linha de comando do cliente para banco de dados MySQL;
  • -u rootEspecifica o nome de usuário usado para efetuar login no banco de dados MySQL root. rootO usuário é a conta de superadministrador do banco de dados MySQL e tem a autoridade mais alta;
  • -pIndica que uma senha é necessária para efetuar login no banco de dados. Depois de inserir este comando, você será solicitado a fornecer uma senha.
C:\Users\minch>mysql -u root -p
Enter password: ****
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 24
Server version: 8.0.32 MySQL Community Server - GPL

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

criar banco de dados

CREATE DATABASE student_score_db;

student_score_dbCrie um banco de dados no banco de dados MySQL chamado

mysql> CREATE DATABASE student_score_db;
Query OK, 1 row affected (0.01 sec)

Alternar para o banco de dados recém-criado

USE student_score_db;

Este comando é usado para selecionar e inserir student_score_dbo banco de dados chamado . Depois de executar este comando, o banco de dados MySQL direcionará as operações da sessão atual para este banco de dados e todos os comandos SQL subsequentes serão executados neste banco de dados.

mysql> USE student_score_db;
Database changed

Criar uma nova tabela de alunos

CREATE TABLE stu_info (
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 学生ID，主键自增长
    name VARCHAR(50) NOT NULL,  -- 学生姓名，不允许为空
    gender ENUM('男', '女') DEFAULT '男',  -- 学生性别，枚举类型，默认为男
    age INT DEFAULT 18,  -- 学生年龄，默认为18岁
    major VARCHAR(50) NOT NULL,  -- 学生所在专业，不允许为空
    class VARCHAR(50) NOT NULL,  -- 学生所在班级，不允许为空
    admission_date DATE NOT NULL  -- 学生入学日期，不允许为空
);

Este comando é utilizado para criar uma tabela nomeada no banco de dados MySQL stu_info, que contém as informações básicas dos alunos, onde:

  • idÉ a chave primária na tabela, usando INTo tipo para representar a carteira do aluno, e PRIMARY KEY AUTO_INCREMENTo campo pode ser auto-incrementado configurando ;
  • nameé o nome do aluno, representado por VARCHAR(50), a configuração NOT NULLsignifica que o campo não pode ficar vazio;
  • genderé o sexo do aluno, ENUM('男', '女')representado por um tipo de enumeração, onde '男'e '女'são valores de enumeração, e use para DEFAULT '男'definir o valor padrão '男';
  • ageé a idade do aluno, INTrepresentada pelo tipo, e DEFAULT 18o valor padrão é definido por 18;
  • majorÉ o maior do aluno, use para VARCHAR(50)indicar, definido para NOT NULLindicar que o campo não pode ficar vazio;
  • classÉ a turma do aluno, use para VARCHAR(50)indicar, configurando NOT NULLsignifica que o campo não pode ficar vazio;
  • admission_dateÉ a data de matrícula do aluno, DATErepresentada pelo tipo, e a configuração NOT NULLsignifica que o campo não pode ficar vazio.
mysql> CREATE TABLE stu_info (
    ->     id INT PRIMARY KEY AUTO_INCREMENT,  -- 学生ID，主键自增长
    ->     name VARCHAR(50) NOT NULL,  -- 学生姓名，不允许为空
    ->     gender ENUM('男', '女') DEFAULT '男',  -- 学生性别，枚举类型，默认为男
    ->     age INT DEFAULT 18,  -- 学生年龄，默认为18岁
    ->     major VARCHAR(50) NOT NULL,  -- 学生所在专业，不允许为空
    ->     class VARCHAR(50) NOT NULL,  -- 学生所在班级，不允许为空
    ->     admission_date DATE NOT NULL  -- 学生入学日期，不允许为空
    -> );
Query OK, 0 rows affected (0.02 sec)

Insira os dados do aluno

INSERT INTO stu_info (name, gender, age, major, class, admission_date)
VALUES 
    ('张三', '男', 19, '计算机科学与技术', '2022计算机1班', '2022-09-01'),
    ('李四', '男', 20, '软件工程', '2021软件1班', '2021-09-01'),
    ('王五', '女', 18, '信息管理与信息系统', '2023信息1班', '2023-09-01'),
    ('赵六', '男', 19, '计算机科学与技术', '2022计算机2班', '2022-09-01'),
    ('刘七', '女', 20, '数据科学与大数据技术', '2021数据1班', '2021-09-01'),
    ('钱八', '男', 18, '网络工程', '2023网络1班', '2023-09-01');

Este comando é stu_infouma instrução usada para inserir vários dados de informações do aluno na tabela. Especificamente, este comando irá inserir 6 registros na tabela, cada um dos quais é VALUESespecificado por uma cláusula, cada cláusula representa o valor de um registro e várias VALUEScláusulas são separadas por vírgulas.

mysql> INSERT INTO stu_info (name, gender, age, major, class, admission_date)
    -> VALUES
    ->     ('张三', '男', 19, '计算机科学与技术', '2022计算机1班', '2022-09-01'),
    ->     ('李四', '男', 20, '软件工程', '2021软件1班', '2021-09-01'),
    ->     ('王五', '女', 18, '信息管理与信息系统', '2023信息1班', '2023-09-01'),
    ->     ('赵六', '男', 19, '计算机科学与技术', '2022计算机2班', '2022-09-01'),
    ->     ('刘七', '女', 20, '数据科学与大数据技术', '2021数据1班', '2021-09-01'),
    ->     ('钱八', '男', 18, '网络工程', '2023网络1班', '2023-09-01');
Query OK, 6 rows affected (0.01 sec)
Records: 6  Duplicates: 0  Warnings: 0

Criar currículo

CREATE TABLE course (
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 课程ID，主键自增长
    name VARCHAR(50) NOT NULL,  -- 课程名称，不允许为空
    teacher_id INT NOT NULL,  -- 教师ID，外键，参考教师表中的ID字段
    credit DOUBLE NOT NULL  -- 课程学分，不允许为空
);

Este comando é coursea instrução usada para criar uma tabela chamada . Especificamente, a tabela contém as seguintes colunas:

  • id: ID do curso, o tipo é INT, é a coluna de chave primária e usa AUTO_INCREMENTo atributo para indicar autocrescimento;
  • name: nome do curso, o tipo é VARCHAR(50), não pode ficar vazio;
  • teacher_id: ID do professor, o tipo é INT, não pode ficar vazio, é uma coluna de chave estrangeira, referente à coluna da tabela do professor ID;
  • credit: crédito do curso, o tipo é DOUBLE, não pode ficar vazio.

Dentre elas, a coluna de chave primária especifica PRIMARY KEYuma restrição, que obriga o valor desta coluna a ser único na tabela, e utiliza AUTO_INCREMENTa palavra-chave para indicar que o valor desta coluna será incrementado automaticamente.

mysql> CREATE TABLE course (
    ->     id INT PRIMARY KEY AUTO_INCREMENT,  -- 课程ID，主键自增长
    ->     name VARCHAR(50) NOT NULL,  -- 课程名称，不允许为空
    ->     teacher_id INT NOT NULL,  -- 教师ID，外键，参考教师表中的ID字段
    ->     credit DOUBLE NOT NULL  -- 课程学分，不允许为空
    -> );
Query OK, 0 rows affected (0.02 sec)

Insira os dados do currículo

INSERT INTO course (name, teacher_id, credit)
VALUES 
    ('高等数学I', 1, 4.0),
    ('Java程序设计', 2, 3.0),
    ('计算机组成原理', 3, 4.0),
    ('数据库原理与应用', 4, 3.5),
    ('操作系统原理', 5, 3.5),
    ('数据结构与算法', 6, 4.5);

Isso é para inserir dados no currículo, a sintaxe específica também foi mencionada acima, consulte o módulo de entrada de dados do aluno;

mysql> INSERT INTO course (name, teacher_id, credit)
    -> VALUES
    ->     ('高等数学I', 1, 4.0),
    ->     ('Java程序设计', 2, 3.0),
    ->     ('计算机组成原理', 3, 4.0),
    ->     ('数据库原理与应用', 4, 3.5),
    ->     ('操作系统原理', 5, 3.5),
    ->     ('数据结构与算法', 6, 4.5);
Query OK, 6 rows affected (0.00 sec)
Records: 6  Duplicates: 0  Warnings: 0

Criar folha de notas

CREATE TABLE score (
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 成绩ID，主键自增长
    student_id INT NOT NULL,  -- 学生ID，外键，参考学生表中的ID字段
    course_id INT NOT NULL,  -- 课程ID，外键，参考课程表中的ID字段
    score DOUBLE NOT NULL  -- 学生得分，不允许为空
);

Crie uma tabela nomeada no banco de dados MySQL scorecom as seguintes colunas:

  • id: Achievement ID, o tipo é INT, é a coluna de chave primária e usa AUTO_INCREMENTo atributo para indicar autocrescimento;
  • student_id: Student ID, o tipo é INT, não pode ficar vazio, é uma coluna de chave estrangeira, referente à coluna da tabela do aluno ID;
  • course_id: course ID, o tipo é INT, não pode ficar vazio, é uma coluna de chave estrangeira, referente à coluna da tabela do curso ID;
  • score: Pontuação do aluno, o tipo é DOUBLE, não pode ficar em branco.

Dentre elas, a coluna de chave primária especifica PRIMARY KEYuma restrição, que obriga o valor desta coluna a ser único na tabela, e utiliza AUTO_INCREMENTa palavra-chave para indicar que o valor desta coluna será incrementado automaticamente.

mysql> CREATE TABLE score (
    ->     id INT PRIMARY KEY AUTO_INCREMENT,  -- 成绩ID，主键自增长
    ->     student_id INT NOT NULL,  -- 学生ID，外键，参考学生表中的ID字段
    ->     course_id INT NOT NULL,  -- 课程ID，外键，参考课程表中的ID字段
    ->     score DOUBLE NOT NULL  -- 学生得分，不允许为空
    -> );
Query OK, 0 rows affected (0.01 sec)

Insira os dados da nota

INSERT INTO score (student_id, course_id, score)
VALUES 
    (1, 1, 85.0),
    (1, 2, 90.5),
    (2, 3, 78.0),
    (2, 4, 92.0),
    (3, 5, 88.5),
    (3, 6, 95.0);

Idem!

mysql> INSERT INTO score (student_id, course_id, score)
    -> VALUES
    ->     (1, 1, 85.0),
    ->     (1, 2, 90.5),
    ->     (2, 3, 78.0),
    ->     (2, 4, 92.0),
    ->     (3, 5, 88.5),
    ->     (3, 6, 95.0);
Query OK, 6 rows affected (0.01 sec)
Records: 6  Duplicates: 0  Warnings: 0

criar mesa do professor

CREATE TABLE teacher (
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 教师ID，主键自增长
    name VARCHAR(50) NOT NULL,  -- 教师姓名，不允许为空
    gender ENUM('男', '女') DEFAULT '男',  -- 教师性别，枚举类型，默认为男
    age INT DEFAULT 35,  -- 教师年龄，默认为35岁
    title VARCHAR(50) NOT NULL  -- 教师职称，不允许为空
);

Crie uma tabela nomeada no banco de dados MySQL teachercom as seguintes colunas:

  • id: ID do professor, o tipo é INT, é a coluna de chave primária e usa AUTO_INCREMENTo atributo para indicar autocrescimento;
  • name: nome do professor, o tipo é VARCHAR(50), não pode ficar vazio;
  • gender: Sexo do professor, o tipo é ENUM('男', '女'), e o valor padrão é '男'. Como há apenas duas possibilidades para sexo, use ENUMo tipo de enumeração para limitar seu intervalo de valores;
  • age: idade do professor, tipo é INT, valor padrão é 35. Como a idade pode ter muitas possibilidades e o valor padrão é 35, use diretamente INTo tipo e defina o valor padrão;
  • title: Título do professor, o tipo é VARCHAR(50), não pode ficar vazio.
mysql> CREATE TABLE teacher (
    ->     id INT PRIMARY KEY AUTO_INCREMENT,  -- 教师ID，主键自增长
    ->     name VARCHAR(50) NOT NULL,  -- 教师姓名，不允许为空
    ->     gender ENUM('男', '女') DEFAULT '男',  -- 教师性别，枚举类型，默认为男
    ->     age INT DEFAULT 35,  -- 教师年龄，默认为35岁
    ->     title VARCHAR(50) NOT NULL  -- 教师职称，不允许为空
    -> );
Query OK, 0 rows affected (0.02 sec)

Insira os dados do professor

INSERT INTO teacher (name, gender, age, title)
VALUES 
    ('张老师', '男', 38, '教授'),
    ('李老师', '女', 39, '副教授'),
    ('王老师', '男', 35, '讲师'),
    ('赵老师', '女', 36, '教授'),
    ('刘老师', '男', 40, '副教授'),
    ('钱老师', '女', 37, '讲师');

Idem!

mysql> INSERT INTO teacher (name, gender, age, title)
    -> VALUES
    ->     ('张老师', '男', 38, '教授'),
    ->     ('李老师', '女', 39, '副教授'),
    ->     ('王老师', '男', 35, '讲师'),
    ->     ('赵老师', '女', 36, '教授'),
    ->     ('刘老师', '男', 40, '副教授'),
    ->     ('钱老师', '女', 37, '讲师');
Query OK, 6 rows affected (0.01 sec)
Records: 6  Duplicates: 0  Warnings: 0

adicionar chave estrangeira

-- 在课程表中添加外键，参考教师表的ID字段
ALTER TABLE course ADD CONSTRAINT fk_course_teacher FOREIGN KEY (teacher_id) REFERENCES teacher(id);

-- 在成绩表中添加外键，参考学生表和课程表的ID字段
ALTER TABLE score ADD CONSTRAINT fk_score_student FOREIGN KEY (student_id) REFERENCES stu_info(id);
ALTER TABLE score ADD CONSTRAINT fk_score_course FOREIGN KEY (course_id) REFERENCES course(id);

Tome o primeiro comando como exemplo;

Esta instrução SQL courseadiciona uma restrição de chave estrangeira na tabela, que contém as seguintes palavras-chave (para explicação específica, consulte a seção de perguntas e respostas):

  • ALTER TABLE: usado para modificar a estrutura da tabela existente;
  • course: o nome da tabela a ser modificada;
  • ADD CONSTRAINT: Adicionar uma restrição;
  • fk_course_teacher: o nome da nova restrição;
  • FOREIGN KEY: Especifique a restrição como uma restrição de chave estrangeira;
  • (teacher_id): O nome da coluna de chave estrangeira, teacherqual coluna na tabela de referência. O conteúdo entre colchetes indica o nome da coluna;
  • REFERENCES teacher(id): a tabela e a coluna referenciadas pela coluna de chave estrangeira. REFERENCESA palavra-chave especifica o nome da tabela referenciada e o conteúdo entre colchetes indica um nome de coluna da tabela, que é usado como o valor de referência da coluna de chave estrangeira.

Resumindo, a função desta instrução SQL é definir a coluna courseda tabela teacher_idcomo uma coluna de chave estrangeira, referindo-se à coluna teacherda tabela id. Desta forma, ao inserir, atualizar ou excluir dados, o banco de dados MySQL verificará automaticamente se as restrições de chave estrangeira foram atendidas, garantindo assim a consistência dos dados entre as tabelas.

Deve-se observar que, para usar restrições de chave estrangeira, a coluna teacherna tabela referenciada deve primeiro ser criada ide definida como a chave primária. Como a função das restrições de chave estrangeira é garantir que um valor de coluna na tabela de referência deva existir em uma coluna na tabela atual, a coluna na tabela de referência deve ser definida como exclusiva e não nula.

mysql> ALTER TABLE course ADD CONSTRAINT fk_course_teacher FOREIGN KEY (teacher_id) REFERENCES teacher(id);
Query OK, 6 rows affected (0.05 sec)
Records: 6  Duplicates: 0  Warnings: 0

mysql> ALTER TABLE score ADD CONSTRAINT fk_score_student FOREIGN KEY (student_id) REFERENCES stu_info(id);
Query OK, 6 rows affected (0.05 sec)
Records: 6  Duplicates: 0  Warnings: 0

mysql> ALTER TABLE score ADD CONSTRAINT fk_score_course FOREIGN KEY (course_id) REFERENCES course(id);
Query OK, 6 rows affected (0.05 sec)
Records: 6  Duplicates: 0  Warnings: 0

Verificar criação

show tables;

Este comando é para exibir todas as tabelas no banco de dados atual e os resultados são os seguintes:

A situação específica dos dados da tabela de consulta será apresentada no blog a seguir;

mysql> show tables;
+----------------------------+
| Tables_in_student_score_db |
+----------------------------+
| course                     |
| score                      |
| stu_info                   |
| teacher                    |
+----------------------------+
4 rows in set (0.00 sec)

Você também pode visualizá-lo através da ferramenta de gerenciamento de banco de dados.A seguir está a tabela de dados visualizada com o Navicat, e o relacionamento da chave estrangeira também é exibido claramente;

Instalação do Navicat: https://blog.jiumoz.com/archives/navicatpremium16-de-po-jie-yu-an-zhuang

Conexão Navicat: https://blog.jiumoz.com/archives/mysql-an-zhuang-pei-zhi-yu-navicat-lian-jie

imagem-20230413183356895

perguntas e respostas

palavra-chave ALTER TABLE

ALTER TABLEÉ uma instrução SQL usada para modificar a estrutura de uma tabela em um banco de dados relacional existente, incluindo operações como adição, modificação e exclusão de colunas. Através ALTER TABLEdo comando podemos expandir ou encolher a tabela criada, o que melhora a flexibilidade e manutenibilidade dos dados.

Por exemplo, podemos usar para ALTER TABLEadicionar novas colunas, atualizar tipos de dados de colunas existentes, adicionar restrições a tabelas, etc. Este comando é uma função essencial em um sistema de gerenciamento de banco de dados relacional (RDBMS).

Vale ressaltar que ALTER TABLEo comando precisa ser utilizado com cautela, pois este comando pode causar a perda de dados da tabela ou destruir a integridade da tabela.

Use ALTER TABLE para adicionar novas colunas

Quando precisamos adicionar uma nova coluna a uma tabela de banco de dados existente, podemos usar ALTER TABLEo comando para conseguir isso. Aqui está um ALTER TABLEexemplo de instrução SQL usando adicionar uma nova coluna:

ALTER TABLE 表名 ADD 列名 数据类型;

Entre eles, 表名indica o nome da tabela de destino a ser modificada, 列名indica o nome da nova coluna a ser adicionada e 数据类型indica o tipo de dados da coluna.

Por exemplo, suponha que temos uma studentstabela nomeada e agora queremos adicionar uma nova coluna na tabela age, seu tipo de dados é inteiro. Você pode usar a seguinte instrução SQL para obter:

ALTER TABLE students ADD age INT;

Depois que a instrução acima for executada, studentsuma nova coluna será adicionada à tabela agee seu tipo de dados é inteiro.

Deve-se observar que quando adicionamos uma nova coluna a uma tabela existente, o valor padrão da nova coluna é NULL. Se você precisar atribuir um valor padrão à nova coluna, poderá usar a palavra-chave DEFAULT. Por exemplo:

ALTER TABLE students ADD address VARCHAR(50) DEFAULT 'N/A';

A instrução SQL acima studentsadicionará uma nova coluna na tabela address, seu tipo de dados é o tipo string e o valor padrão é atribuído 'N/A'.

palavra-chave ADD CONSTRAINT

ADD CONSTRAINTÉ uma instrução SQL utilizada para adicionar restrições (constraint) a uma tabela de banco de dados relacional, e geralmente é ALTER TABLEutilizada em conjunto com o comando. Muitos tipos de restrições podem ser ADD CONSTRAINTadicionados usando , como restrições de chave primária, restrições exclusivas, restrições de chave estrangeira e muito mais.

Veja a seguir um exemplo de instrução SQL para adicionar uma restrição de chave primária:

ALTER TABLE table_name ADD CONSTRAINT pk_column PRIMARY KEY (column1, column2);

onde table_nameé o nome da tabela de destino, pk_columné o nome da restrição de chave primária a ser incluída column1e column2é o nome da coluna a ser incluída na restrição de chave primária.

Deve-se observar que, antes de executar este comando, você deve garantir que a tabela de destino já contenha as colunas e os dados necessários, e essas colunas devem ser definidas como não anuláveis ​​(ou seja, NOT NULL). Caso contrário, a adição de restrições falhará porque as restrições não podem ser satisfeitas.

o que significa restrição

Restrição (Constraint) é uma regra usada para definir as regras de dados e integridade na tabela para garantir a correção, consistência e validade dos dados. As restrições podem limitar o intervalo de valores, a necessidade e a exclusividade de determinadas colunas em uma tabela e também podem definir relacionamentos entre tabelas, como chaves primárias e chaves estrangeiras.

As restrições comuns do MySQL incluem:

  • CHAVE PRIMÁRIA: A restrição de chave primária é usada para identificar exclusivamente cada linha de dados na tabela.
  • UNIQUE: A restrição única, usada para limitar os dados na coluna, não pode ser repetida.
  • NOT NULL: Restrição não nula, usada para restringir os dados na coluna não pode estar vazia.
  • CHECK: As restrições de verificação, usadas para limitar os dados na coluna, devem atender às condições especificadas.
  • FOREIGN KEY: As restrições de chave estrangeira são usadas para definir o relacionamento entre duas tabelas para garantir que os dados na tabela filho sempre correspondam aos dados na tabela pai.

Deve-se notar que no MySQL, as restrições podem ser definidas juntas quando a tabela é criada, ou podem ser adicionadas e modificadas através da instrução ALTER TABLE após a criação da tabela.

Diferença entre chave primária e restrição de chave primária

Chave Primária e Restrição de Chave Primária são conceitos intimamente relacionados, mas não idênticos.

Uma chave primária é uma coluna ou colunas usadas para identificar exclusivamente cada registro em uma tabela de banco de dados relacional (garantir que seus valores combinados sejam únicos em toda a tabela) . As colunas contidas na chave primária devem atender às condições de que cada linha de dados seja única e não nula. A chave primária geralmente é usada para consultar, atualizar e excluir dados na tabela. Em uma tabela, a chave primária é definida por valores de coluna específicos, em vez de uma restrição independente definida na tabela.

Uma restrição de chave primária é uma restrição aplicada à coluna de chave primária para garantir a integridade da chave primária. É uma restrição especial usada principalmente para especificar que a chave primária na tabela deve atender às condições de exclusividade e não -nulidade. A restrição de chave primária geralmente é implementada por um sistema de gerenciamento de banco de dados relacional (RDBMS), que impede que os usuários executem operações na coluna de chave primária que destruirão a integridade dos dados, como modificar ou excluir determinados dados na coluna de chave primária.

Em aplicações práticas, geralmente usamos a chave primária como elemento básico e usamos a restrição de chave primária para garantir a integridade e a exclusividade dos dados da coluna contidos na chave primária, melhorando assim a estabilidade e a segurança do banco de dados.

As restrições de chave primária podem restringir colunas de chave não primária?

Em um banco de dados relacional, uma restrição de chave primária é uma restrição aplicada à coluna de chave primária para garantir a exclusividade e não nulidade da coluna de chave primária na tabela. Portanto, a restrição de chave primária só pode ser aplicada à coluna de chave primária na tabela, mas não a outras colunas.

Além das restrições de chave primária, em bancos de dados relacionais, também existem restrições únicas (UNIQUE Constraint) que podem ser aplicadas a diferentes colunas em uma tabela para garantir que os valores dessas colunas sejam únicos. Além disso, a restrição de verificação (CHECK Constraint) pode restringir as colunas de chave não primária na tabela em alguns casos para evitar dados inesperados ou errados.

Aplicação de restrições do MySQL em desenvolvimento

Uma restrição do MySQL é uma regra que restringe os valores de determinadas colunas em uma tabela de banco de dados ou o relacionamento entre elas. Garante a integridade e consistência dos dados, evitando que dados inválidos ou errados sejam armazenados no banco de dados. Veja como as restrições do MySQL se aplicam no desenvolvimento:

  1. Restrição de chave primária: pode garantir que cada linha de dados na tabela tenha um identificador exclusivo e esse identificador não pode estar vazio. As restrições de chave primária também melhoram o desempenho ao consultar e classificar.
  2. Restrições de chave estrangeira: pode garantir que os campos em uma tabela que apontam para outras tabelas contenham apenas valores que existam nessa tabela. As restrições de chave estrangeira também impedem a exclusão acidental de dados (como a exclusão de dados referenciados por outras tabelas).
  3. Restrição única: pode garantir que o valor de uma determinada coluna na tabela seja único, e também pode impedir que valores nulos apareçam em uma coluna específica.
  4. Restrição não nula: pode garantir que uma coluna na tabela não esteja vazia.
  5. Restrições de verificação: regras adicionais podem ser definidas para garantir que os valores de dados de uma coluna ou colunas estejam em conformidade com a especificação. Por exemplo, você pode usar uma restrição de verificação para garantir que um campo de data seja sempre uma data após a data atual.
  6. Restrição de valor padrão: Você pode especificar um valor padrão para um campo e, se o campo não for escrito ao inserir dados, o valor padrão será preenchido automaticamente.
  7. Restrições compostas: as regras podem ser impostas em várias colunas simultaneamente para garantir que as informações em uma tabela sejam estruturadas corretamente.

Exemplo de aplicação de restrição MySQL em fastapi

Ao usar o banco de dados MySQL no FastAPI, você pode definir e gerenciar restrições por meio do SQLAlchemy e nomeá-las. Aqui está um exemplo mostrando como criar e nomear restrições em FastAPI e MySQL:

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False, unique=True, name="unique_user_name")
    age = Column(Integer, nullable=False)

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False, name="item_name_not_null")
    price = Column(Integer, nullable=False)
    user_id = Column(Integer, ForeignKey('users.id'))
    user = relationship("User", backref="items")

No exemplo acima, adicionamos nomes de restrição para a coluna de nome na tabela de usuários e a coluna de nome na tabela de itens: unique_user_name e item_name_not_null. Os nomes dessas restrições facilitam a localização e compreensão da estrutura da tabela por outros desenvolvedores, bem como a manutenção e depuração do código.

Para usar o modelo definido acima e criar sua tabela MySQL correspondente, as seguintes etapas precisam ser executadas usando o SQLAlchemy e o banco de dados MySQL:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "mysql://user:password@localhost/db_name"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL
)

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base.metadata.create_all(bind=engine)

No exemplo acima, primeiro criamos um mecanismo SQLAlchemy e definimos uma classe SessionLocal para acesso ao banco de dados. Em seguida, usamos o método create_all() para criar todas as estruturas de tabela e associá-las ao banco de dados MySQL conectado.

Se o nome da restrição deve corresponder ao nome da restrição no banco de dados

Se um nome de restrição do MySQL for definido no código, seu nome de restrição correspondente deve corresponder a ele no banco de dados. Isso ocorre porque o nome da restrição do MySQL é um tipo de metadado definido quando a tabela é criada e será armazenado nas tabelas do sistema do banco de dados. Ao modificar ou descartar restrições existentes, o MySQL precisa saber exatamente quais restrições devem ser alteradas.

Se os nomes das restrições do MySQL definidos no código não corresponderem aos armazenados no banco de dados real, ocorrerá um erro. Por exemplo, se você definir uma restrição única chamada "unique_user_name", mas o MySQL nomeá-la como "uq_users_name_5588" quando a tabela for realmente criada, ocorrerão erros ao consultar e atualizar os dados relacionados.

Portanto, ao adicionar nomes de restrição do MySQL no desenvolvimento, é importante garantir que cada nome de restrição corresponda ao nome realmente armazenado no banco de dados. Além disso, nomes muito longos ou pouco claros devem ser evitados para localizar rapidamente problemas de restrição no futuro.

Endereço original: https://blog.jiumoz.com/archives/sql-bi-ji-1mysql-chuang-jian-shu-ju-ku

Bem-vindo a seguir o miniprograma pessoal do blogueiro!

Acho que você gosta

Origin blog.csdn.net/qq_45730223/article/details/130142908
Recomendado
Clasificación
Diario
Más
2024-05-22(9)
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)
2024-05-18(32)
2024-05-17(5)
2024-05-16(24)
2024-05-15(5)
2024-05-14(11)
2024-05-13(7)

Code World

© 2018 codetd.com