Как задать первичный ключ sql
Перейти к содержимому

Как задать первичный ключ sql

  • автор:

Как задать первичный ключ sql

В SQL ограничение PRIMARY KEY используется для уникальной идентификации строк.

Ограничение PRIMARY KEY — это просто комбинация ограничений NOT NULL и UNIQUE. Это означает, что столбец не может содержать повторяющиеся значения, а также значения NULL .

Синтаксис создания первичного ключа:

Здесь столбец college_id имеет первичный ключ. Это означает, что значения этого столбца должны быть уникальными, а также не содержать значения NULL .

Примечание: Синтаксис создания первичного ключа может отличаться в некоторых СУБД.

Ошибка первичного ключа

Если мы попытаемся вставить нулевые или повторяющиеся значения в столбец с первичным ключом, то получим ошибку. Например:

SQL — Создание первичного ключа

От автора: в этой статье мы поговорим про создание первичного ключа SQL. Первичный ключ — это поле в таблице, которое однозначно идентифицирует каждую строку/запись в таблице базы данных. Первичные ключи должны содержать уникальные значения. В столбце первичного ключа не может содержаться значений NULL.

В таблице может быть только один первичный ключ, который может состоять из одного или нескольких полей. Когда в качестве первичного ключа используются несколько полей, он называется составным.

Если для таблицы первичный ключ задан в определенном поле, то в этом поле не может содержаться двух записей с одинаковыми значениями.

Примечание. Вы должны учитывать данные принципы при создании таблиц базы данных.

Создание первичного ключа

Ниже приведен код, в котором столбец ID определяется в качестве первичного ключа для таблицы CUSTOMERS.

SQL Primary Keys

В этом учебном материале вы узнаете, как создать и удалить первичный ключ в SQL, с синтаксисом и примерами.

Что такое первичный ключ в SQL?

В SQL первичный ключ — это отдельное поле или комбинация полей, которые однозначно определяют запись. Ни одно из полей, являющихся частью первичного ключа, не может содержать значение NULL. Таблица может иметь только один первичный ключ.
Вы можете использовать оператор CREATE TABLE или оператор ALTER TABLE для создания первичного ключа в SQL.

Создать первичный ключ (оператор CREATE TABLE)

Первичный ключ может быть создан при выполнении оператора CREATE TABLE в SQL.

Синтаксис

Синтаксис для создания первичного ключа с помощью оператора CREATE TABLE в SQL.

CONSTRAINT constraint_name PRIMARY KEY (pk_col1, pk_col2, . pk_col_n)
);

Пример

Давайте посмотрим, как создать первичный ключ с помощью оператора CREATE TABLE в SQL. Мы начнем с очень простого, где наш первичный ключ состоит всего из одного столбца.
Например:

How To Use Primary Keys in SQL

One of the valuable traits of relational databases is molding the data into a well-defined structure. This structure is achieved by using tables with fixed columns, following strictly defined datatypes, and ensuring that each row has the same shape. When you store data as rows in tables, it is equally important to be able to find them and refer to them without ambiguity. In Structured Query Language (SQL), this can be achieved with primary keys, which serve as identifiers for individual rows in the tables in the relational database.

In this tutorial, you’ll learn about primary keys and use a few different kinds to identify unique rows in database tables. Using some sample datasets, you’ll create primary keys on single columns and multiple columns, and autoincrement sequential keys.

Prerequisites

To follow this guide, you will need a computer running a SQL-based relational database management system (RDBMS). The instructions and examples in this guide were validated using the following environment:

  • A server running Ubuntu 20.04, with a non-root user with administrative privileges and a firewall configured with UFW, as described in our initial server setup guide for Ubuntu 20.04.
  • MySQL installed and secured on the server, as outlined in How To Install MySQL on Ubuntu 20.04. This guide was verified with a non-root MySQL user, created using the process described in Step 3.
  • Basic familiarity with executing SELECT queries to retrieve data from the database as described in our How To SELECT Rows FROM Tables in SQL guide.

Note: Please note that many RDBMSs use their own unique implementations of SQL. Although the commands outlined in this tutorial will work on most RDBMSs and primary keys are a part of the SQL standard, some features are database-specific and thus the exact syntax or output may differ if you test them on a system other than MySQL.

You’ll also need an empty database in which you’ll be able to create tables demonstrating the use of primary keys. We encourage you to go through the following Connecting to MySQL and Setting up a Sample Database section for details on connecting to a MySQL server and creating the testing database used in examples throughout this guide.

Connecting to MySQL and Setting up a Sample Database

In this section, you will connect to a MySQL server and create a sample database so that you can follow the examples in this guide.

If your SQL database system runs on a remote server, SSH into your server from your local machine:

Then open up the MySQL server prompt, replacing sammy with the name of your MySQL user account:

Create a database named primary_keys :

If the database was created successfully, you’ll receive output like this:

To select the primary_keys database, run the following USE statement:

You will receive the following output:

After selecting the database, you can create sample tables within it. You’re now ready to follow the rest of the guide and begin working with primary keys in MySQL.

Introduction to Primary Keys

Data in a relational database is stored in tables with a particular, uniform structure of individual rows. The table definition describes what columns there are and what data types can be saved in individual columns. That alone is enough to store the information in the database and find it later using different filtering criteria by using the WHERE clause. However, this structure doesn’t guarantee the possibility of finding any single row unambiguously.

Imagine a database of all registered vehicles allowed to drive on public roads. The database would contain such information as the car brand, model, manufacture year, and paint color. However, if you were looking for a red Chevrolet Camaro made in 2007, you could find more than one. After all, car producers sell similar cars to multiple customers. That’s why registered cars have license plate numbers uniquely identifying each vehicle. If you looked up a car with a license plate of OFP857 , you could be sure this criterion will find only one car. That’s because, by law, plate numbers uniquely identify registered vehicles. In a relational database, such a piece of data is called a primary key.

Primary keys are unique identifiers found in a single column or a set of columns that can unambiguously identify every row in a database table. A few rules reflect the technical properties of primary keys:

  • A primary key must use unique values. If the primary key consists of more than one column, the combination of values in these columns must be unique across the whole table. Since the key is meant to identify every row uniquely, it can’t appear more than once.
  • A primary key must not contain NULL values.
  • Each database table can use only one primary key.

The database engine enforces these rules, so you can rely on those properties being true if the primary key is defined on a table.

In addition to these technical properties, you must also consider the content of the data to decide what kind of data is a good choice for becoming a primary key. Natural keys are identifiers already present in the data set, while surrogate keys are artificial identifiers.

Some data structures have primary keys that naturally occur within the data set, such as license plate numbers in a car database or social security numbers in the directory of US citizens. Sometimes such identifiers are not a single value but a pair or a combination of several values. For example, in a local city directory of houses, just a street name or a street number, cannot identify a house uniquely. There can be multiple houses on a single street, and the same number can appear on multiple streets. But a pair of street names and numbers can be assumed to be a unique house identifier. Such naturally occurring identifiers are called natural keys.

However, often data can’t be uniquely characterized by the values of a single column or a small subset of columns. Then, artificial primary keys are created, for example, using a sequence of numbers or randomly generated identifiers like UUIDs. Such keys are called surrogate keys.

In the following sections, you’ll create natural keys based on a single column or multiple columns, and generate surrogate keys on tables where a natural key is not an option.

Creating a Primary Key on a Single Column

In many cases, a data set naturally contains a single column that can be used to identify rows in the table uniquely. In these cases, you can create a natural key to describe the data. Following the previous example of the database of registered cars, imagine a table with the following structure:

The first and second rows both describe a red Ford Mustang from 2018. By using only car make and model, you wouldn’t be able to identify the car uniquely. The license plate differs in both instances, providing a good unique identifier for every row in the table. Because a license plate number is already part of the data, using that as a primary key would create a natural key. If you created the table without using a primary key on the license_plate column, you would risk a duplicate or an empty plate appearing in the data set at some point in time.

Next, you’ll create a table resembling the one above with the license_plate column used as a primary key and the following columns:

  • license_plate : This column holds the license plate number, represented by the varchar data type.
  • brand : This column holds the brand of the car, expressed using the varchar data type with a maximum of 50 characters.
  • model : This column holds the car’s model, expressed using the varchar data type with a maximum of 50 characters.
  • color : This column holds the color, expressed using the varchar data type with a maximum of 20 characters.
  • year : This column holds the year the car was made, expressed using the int data type to store numerical data.

To create the cars table, execute the following SQL statement:

The PRIMARY KEY clause follows the license_plate data type definition. When dealing with primary keys based on single columns, you can use the simplified syntax to create the key, writing PRIMARY KEY in the column definition.

If the following output prints, the table has been created:

Following that, load the table with the sample rows presented in the example above by running the following INSERT INTO operation:

The database will respond with the success message:

You can now verify, using the SELECT statement, that the newly created table contains the anticipated data and format:

The output will show a table similar to the one at the beginning of the section:

Next, you can verify whether the rules for the primary key are guaranteed by the database engine. Try inserting a car with a duplicate plate number by executing:

MySQL will respond with an error message, saying that the DEF456 license plate would result in a duplicate entry for the primary key:

Note: Under the hood, primary keys are implemented with unique indexes and share many properties with indexes you might create manually for other columns on the table. Most importantly, primary key indexes also improve the performance of querying the table against the column the index is defined on. To learn more about using indexes for that purpose, see the How to Use Indexes guide in this tutorial series.

You can now be sure that duplicate license plates are not allowed. Next, check whether it’s possible to insert a car with an empty license plate:

This time, the database will respond with another error message:

With these two rules enforced by the database, you can be sure that the license_plate identifies every row in the table uniquely. If you query the table against any license plate, you can expect a single row returned every time.

In the next section, you’ll learn how to use primary keys with multiple columns.

Creating a Primary Key on Multiple Columns

When one column is not enough to identify a unique row in the table, you can create primary keys that use more than one column.

For example, imagine a registry of homes where neither the street name nor the street number alone is enough to identify any individual house:

The street name Central Park West appears more than once in the table, and so does the street number 100 . However, no duplicate pairs of street names and street numbers are visible. In this case, while no single column could be a primary key, the pair of those two values can be used to identify each row in the table uniquely.

Next, you’ll create a table resembling the one shown above with the following columns:

  • street_name : This column holds the name of the street where the house is located, represented by the varchar data type limited to 50 characters.
  • street_number : This column holds the house’s street number, represented by the varchar data type. This column can store up to 5 characters. It doesn’t use numerical int data type because some street numbers might contain letters (for example, 200B ).
  • house_owner : This column holds the name of the house’s owner, represented by the varchar data type limited to 50 characters.
  • year : This column holds the year the house was built, represented by the int data type to store numerical values.

This time, the primary key will use both the street_name and street_number columns, rather than a single column. To do so, execute the following SQL statement:

This time, the PRIMARY KEY clause appears below the column definitions, unlike the previous example. The PRIMARY KEY statement is followed by parentheses with two column names inside: street_name and street_number . This syntax creates the primary key in the houses table spanning two columns.

If the following output prints, the table has been created:

Following that, load the table with the sample rows presented in the previous example by running the following INSERT INTO operation:

The database will respond with the success message:

You can now verify, using the SELECT statement, that the newly created table contains the anticipated data and format:

The output will show a table similar to the one at the beginning of the section:

Now, let’s verify if the database will allow inserting rows that duplicate street names and street numbers, but restrict duplicate full addresses from appearing in the table. Let’s start by adding another house on Park Avenue:

MySQL will respond with a success message since the address 8000 Park Avenue didn’t appear in the table previously:

A similar result will happen when you add a house on 8000 Main Street , repeating the street number:

Once again, this will insert a new row properly since the entire address doesn’t duplicate:

However, try adding another house on 100 5th Avenue using the INSERT statement below:

The database will respond with an error message, notifying you that there is a duplicate entry for the primary key for the pair of values 5th Avenue and 100 :

The database properly enforces the primary key rules, with the key defined on a pair of columns. You can be sure that the full address consisting of a street name and street number won’t get duplicated in the table.

In this section, you created a natural key with a pair of columns to identify every row in the house table uniquely. But it’s not always possible to derive primary keys from the dataset. In the next section, you’ll use artificial primary keys that don’t come directly from the data.

Creating a Sequential Primary Key

Until now, you’ve created unique primary keys using existing columns in the sample data sets. But in some cases, the data will inevitably duplicate, preventing any columns from being good unique identifiers. In these cases, you can create sequential primary keys using generated identifiers. When the data at your disposal requires you to devise new identifiers to identify rows uniquely, the primary keys created on those artificial identifiers are called surrogate keys.

Imagine a list of book club members—an informal gathering where anyone can join without showing a government-issued ID. There is a chance people with matching names will join the club at some point in time:

The names Bob Johnson and Jane Smith are repeated in the table. You need to use an additional identifier to be sure who is who, and it’s not possible to identify rows uniquely in that table in any way. If you kept the list of book club members on paper, you could keep auxiliary identifiers to help distinguish people with the same names among the group.

You can do a similar thing in a relational database by using an additional column holding generated, factless identifiers with the sole purpose of uniquely separating all rows in the table. Let’s call it member_id .

However, it would be a burden to come up with such an identifier whenever you wanted to add another book club member to the database. To solve this, MySQL provides a feature for auto-incremented numerical columns, where the database automatically provides the column value by an incrementing sequence of integers.

Let’s create a table resembling the one shown above. You’ll add an additional auto-incrementing column ( member_id ) to hold the automatically assigned number for each club member. That automatically assigned number will act as the primary key for the table:

  • member_id : This column holds an auto-incremented, numerical identifier represented by the int data type.
  • first_name : This column holds the first name of the club members, represented by the varchar data type limited to 50 characters.
  • last_name : This column holds the last name of the club members, represented by the varchar data type limited to 50 characters.

To create the table, execute the following SQL statement:

While the PRIMARY KEY clause appears after the column type definition, just like a single column primary key, an additional attribute appears before it: AUTO_INCREMENT . It tells MySQL to auto-generate values for that column, if not explicitly provided, using a growing sequence of numbers.

Note: The AUTO_INCREMENT property for defining a column is specific to MySQL. Other databases often provide similar methods for generating sequential keys, but the syntax differs among engines. When in doubt, we encourage you to refer to the official documentation of your RDBMS.

If the following output prints, the table has been created:

Following that, load the table with the sample rows presented in the example above by running the following INSERT INTO operation:

The INSERT statement now includes the list of column names ( first_name and last_name ), which ensures the database knows that the member_id column is not supplied in the dataset, so the default value for it should be taken instead.

The database will respond with the success message:

Use the SELECT statement to verify the data in the newly created table:

The output will show a table similar to the one at the beginning of the section:

However, this time, the member_id column appears in the result and contains a sequence of numbers from 1 to 10 . With this column in place, duplicate rows for Jane Smith and Bob Johnson are no longer indistinguishable since each name is associated with a unique identifier ( member_id ).

Now, let’s verify if the database will allow adding another Tom Thompson to the list of club members:

MySQL will respond with a success message:

To check what numerical identifier was assigned to the new entry by the database, execute the SELECT query again:

There is one more row in the output:

A new row was automatically assigned number 11 in the member_id column through the AUTO_INCREMENT feature of the database.

If the data you are working with doesn’t have natural candidates for primary keys, and you don’t want to provide invented identifiers every time you add new data to the database, you can safely rely on sequentially generated identifiers as primary keys.

Conclusion

By following this guide, you learned what primary keys are and how to create the common types in MySQL to identify unique rows in database tables. You built natural primary keys, created primary keys spanning multiple columns, and used autoincrementing sequential keys where natural keys are not present.

You can use primary keys to shape the database structure further, ensuring data rows will be uniquely identifiable. This tutorial covered only the basics of using primary keys. To learn more about that, refer to the MySQL documentation on constraints. You can also check out our guides on Understanding SQL Constraints and How To Use Constraints in SQL.

If you’d like to learn more about different concepts around the SQL language and working with it, we encourage you to check out the other guides in the How To Use SQL series.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Tutorial Series: How To Use SQL

Series Description

Structured Query Language — commonly known as SQL — is a language used to define, control, manipulate, and query data held in a relational database. SQL has been widely adopted since it was first developed in the 1970s, and today it’s the predominant language used to manage relational database management systems.

Ideal for managing structured data (data that can fit neatly into an existing data model), SQL is an essential tool for developers and system administrators in a wide variety of contexts. Also, because of its maturity and prevalence, candidates with SQL experience are highly sought after for jobs across a number of industries.

This series is intended to help you get started with using SQL. It includes a mix of conceptual articles and tutorials which provide introductions to various SQL concepts and practices. You can also use the entries in this series for reference while you continue to hone your skills with SQL.

Note: Please be aware that the tutorials in this series use MySQL in examples, but many RDBMSs use their own unique implementations of SQL. Although the commands outlined in this tutorial will work on most RDBMSs, the exact syntax or output may differ if you test them on a system other than MySQL.

Похожие публикации:

  1. Как вывести последнюю дату в sql
  2. Как вызывается функция в sql
  3. Как добавить sql файл в базу данных
  4. Как добавить пользователя в sql server 2008

Удаление первичных ключей

Вы можете удалить первичный ключ в SQL Server с помощью SQL Server Management Studio или Transact-SQL.

При удалении первичного ключа удаляется и соответствующий индекс. Это может быть кластеризованный индекс таблицы, в результате чего таблица станет кучей. Дополнительные сведения см. в статье Кучи (таблицы без кластеризованных индексов). Большинство таблиц должны иметь кластеризованный индекс. Сведения о повторном создании первичного ключа см. в разделе Создание первичных ключей.

Первичные ключи могут ссылаться на внешние ключи в другой таблице. Если на внешний ключ ссылается, сначала необходимо удалить ссылки на внешние ключи, а затем удалить первичный ключ. Дополнительные сведения см. в статье Primary and Foreign Key Constraints.

Разрешения

Требуется разрешение ALTER на таблицу.

Использование SQL Server Management Studio

Удаление ограничения первичного ключа с помощью обозревателя объектов

  1. В Обозревателе объектов разверните таблицу, которая содержит первичный ключ, и разверните узел Ключи.
  2. Щелкните ключ правой кнопкой мыши и выберите команду Удалить.
  3. В диалоговом окне Удаление объекта убедитесь в том, что выбран правильный ключ, и нажмите кнопку ОК.

Удаление ограничения первичного ключа с помощью конструктора таблиц

  1. В обозревателе объектов щелкните таблицу с первичным ключом правой кнопкой мыши и выберите пункт Конструктор.
  2. В сетке таблицы щелкните правой кнопкой строку с первичным ключом и выберите пункт Удалить первичный ключ , чтобы переключить параметр.

Примечание. Чтобы отменить это действие, закройте таблицу, не сохраняя изменений. Удаление первичного ключа не может быть отменено без потери всех других изменений, сделанных в таблице.

Использование Transact-SQL

Удаление ограничения первичного ключа

  1. В обозревателе объектов подключитесь к экземпляру ядра СУБД.
  2. На стандартной панели выберите пункт Создать запрос.
  3. Скопируйте приведенный ниже пример в окно запроса и нажмите кнопку Выполнить. В этом примере сначала определяется имя ограничения первичного ключа, а затем удаляется ограничение.
USE AdventureWorks2022; GO -- Return the name of primary key. SELECT name FROM sys.key_constraints WHERE type = 'PK' AND OBJECT_NAME(parent_object_id) = N'TransactionHistoryArchive'; GO -- Delete the primary key constraint. ALTER TABLE Production.TransactionHistoryArchive DROP CONSTRAINT PK_TransactionHistoryArchive_TransactionID; GO 

Следующие шаги

  • Инструкция ALTER TABLE (Transact-SQL)
  • sys.key_constraints (Transact-SQL)
  • Кластеризованные и некластеризованные индексы

Создать первичный ключ для таблицы sql

ключи sql

;)

В этой статье мы попробуем рассмотреть все, что касается ключей в SQL: для чего нужны, создание, ограничения ключей. В общем: будет скучно

План на сегодня такой:

В теории реляционных баз данных — ключи это некие сущности, созданы для установления определенных ограничений, которые поддерживают целостность и доступность данных в таблицах баз данных.

Если говорить простыми словами, то ключи в sql созданы для того, чтобы указать дополнительную функциональность столбца. Будь то уникальность или то, что столбец ссылается на другую таблицу (внешний ключ).

Первичный ключ

Столбец, который в базе данных должен быть уникальным помечают первичным ключом. Первичный ключ или primary key означает, что в таблице значение колонки primary key не может повторяться. Таким образом данный ключ позволяет однозначно идентифицировать запись в таблице не боясь при этом, что значение столбца повториться. Сразу пример: допустим у Вас есть таблица пользователей. В данной таблице есть поля: ФИО, год рождения, телефон. Как идентифицировать пользователя? Таким параметрам как ФИО и телефон доверять нельзя. Ведь у нас может быть несколько пользователей не только с одинаковой фамилией, но и с именем. Телефон может меняться со временем и пользователь с номером телефона может оказаться не тем кто у нас в базе данных.

Вот для этого и придумали первичный ключ. Один раз присвоили уникальный идентификатор и все. В mySql на примере которой мы выполняем все примеры из цикла статей по SQL поле AUTO_INCREMENT нельзя задать если не указать, что это первичный ключ.

К стати, в предыдущей теме мы уже познакомились с первичным ключом: что это такое и как его создавать. Синтаксис по созданию этого ключа Вы найдете в статье Создание, изменение, удаление таблиц SQL.

Читайте также: Таблица растворимости ионы названия

Думаю, что не стоит упоминать, что поле помеченное как первичный ключ не может быть пустым при создании записи.

Внешний ключ (foreign key)

Есть еще внешний ключ (foreign key). Его еще называют ссылочным. Он нужен для связывания таблиц между собой.

усложненная модель

Если посмотреть на картинку выше, то внешним ключем будет поле поставщик в таблице обувь. Как правило, при создании таблицы задают колонку уникальных целочисленных значений. Как мы это делали когда создавали таблицу supplier.

успешное создание таблицы

Колонка supplier_id будет уникальна для каждой записи. Ее значение и будет выступать на мести колонки поставщик в таблице обувь. Предлагаю сразу и рассмотреть на примере как создается внешний ключ.

Создание внешнего ключа

создание внешнего ключа

Как видно на примере выше, синтаксис по созданию внешнего ключа довольно прост. Нужно в таблицу добавить поле, а после объявить это поле как внешний ключ и указать, куда он будет ссылаться. В данном случае поле supplier будет ссылаться на поле supplier_id в таблице supplier.

Составной ключ (composite key)

Что касается составного ключа — это несколько первичных ключей в таблице. Таким образом, создав composite key, уникальность записи будет проверяться по полям, которые объединенные в этот ключ.

Бывают ситуации, когда при вставке в таблицу нужно проверять запись на уникальность сразу по нескольким полям. Вот для этого и придуман составной ключ. Для примера я создам простую таблицу с composite key, чтобы показать синтаксис:

составной ключ

В примере выше два поля объединенные в составной ключ и в таблице не будет записей с этими одинаковыми полями.

Это все, что касается ключей в SQL. Это небольшое пособие — подготовка к статье связи sql где мы подробно рассмотрим как объединять таблицы, чтобы они составляли единую базу данных.

Создание первичных ключей

Применимо к: SQL Server 2016 (13.x); и более поздние версии База данных SQL Azure Управляемый экземпляр SQL Azure

Определить первичный ключ в SQL Server можно с помощью среды SQL Server Management Studio или Transact-SQL. Создание первичного ключа автоматически приводит к созданию соответствующего уникального кластеризованного индекса (или некластеризованного при наличии такого указания).

Перед началом

Ограничения

В таблице возможно наличие только одного ограничения по первичному ключу.

Все столбцы с ограничением PRIMARY KEY должны иметь признак NOT NULL. Если допустимость значения NULL не указана, то для всех столбцов c ограничением PRIMARY KEY устанавливается признак NOT NULL.

безопасность

Permissions

Создание новой таблицы с первичным ключом требует разрешения CREATE TABLE в базе данных и разрешения ALTER на схему, в которой создается таблица.

Создание первичного ключа в существующей таблице требует разрешения ALTER на таблицу.

Использование среды SQL Server Management Studio

Создание первичного ключа

  1. В обозревателе объектов щелкните правой кнопкой мыши таблицу, в которую необходимо добавить ограничение уникальности, и выберите Конструктор.
  2. В Конструкторе таблиц щелкните селектор строк для столбца базы данных, который необходимо определить в качестве первичного ключа. Чтобы выделить несколько столбцов, нажмите и удерживайте клавишу CTRL и щелкните селекторы строк для остальных столбцов.
  3. Щелкните правой кнопкой мыши средство выбора строк столбца и выберите команду Задать первичный ключ.

Чтобы переопределить первичный ключ, необходимо удалить все связи с существующим первичным ключом и только после этого создавать новый первичный ключ. Появится сообщение, предупреждающее об автоматическом удалении в ходе процесса всех существующих связей.

Ключевой столбец-источник идентифицируется символом первичного ключа в соответствующем селекторе строк.

Если первичный ключ состоит более чем из одного столбца, то в одном столбце могут встречаться дублирующиеся значения, но все сочетания значений изо всех столбцов первичного ключа должны быть уникальными.

При определении составного ключа порядок столбцов в первичном ключе совпадает с порядком столбцов, показанным в таблице. Однако после создания первичного ключа порядок столбцов можно изменить. Дополнительные сведения см. в разделе Изменение первичных ключей.

Использование Transact-SQL

Создание первичного ключа в существующей таблице

В следующем примере создается первичный ключ для столбца TransactionID в базе данных AdventureWorks.

Создание первичного ключа в новой таблице

В следующем примере создается таблица и определяется первичный ключ для столбца TransactionID в базе данных AdventureWorks.

Создание первичного ключа с кластеризованным индексом в новой таблице

В следующем примере создается таблица и определяется первичный ключ для столбца CustomerID и кластеризованного индекса для TransactionID в базе данных AdventureWorks.

SQL ПЕРВИЧНЫЙ КЛЮЧ

ОСНОВНОЙ КЛЮЧ

SQL PRIMARY KEY — это столбец в таблице, который должен содержать уникальное значение, которое можно использовать для уникальной идентификации каждой строки таблицы.

Тем не менее, SQL поддерживает первичные ключи напрямую с ограничением PRIMARY KEY.

«ОСНОВНОЙ

Функционально это то же самое, что и ограничение UNIQUE, за исключением того, что для данной таблицы можно определить только один PRIMARY KEY. PRIMARY KEY не допускает значения NULL.

Первичный ключ используется для идентификации каждой строки идентично в таблице. Это может быть частью самой записи.

SQL PRIMARY KEY может состоять из одного или нескольких полей в таблице, и когда это происходит, они называются составным ключом.

Первичные ключи могут быть указаны во время CREATING TABLE или во время изменения структуры существующей таблицы с помощью инструкции ALTER TABLE.

Это ограничение является комбинацией ограничения NOT NULL и ограничения UNIQUE. Это ограничение гарантирует, что конкретный столбец или комбинация из двух или более столбцов для таблицы имеют уникальную идентификацию, которая помогает легче и быстрее найти конкретную запись в таблице.

Синтаксис:

Параметры:

название Описание
table_name Имя таблицы, в которой хранятся данные.
column1, column2 Наименование столбцов таблицы.
тип данных Это char, varchar, целое число, десятичное число, дата и многое другое.
размер Максимальная длина столбца таблицы.

Хорошая практика для первичных ключей в таблицах

  • Первичные ключи должны быть настолько маленькими, насколько это необходимо. Предпочитайте числовой тип, потому что числовые типы хранятся в гораздо более компактном формате, чем символьные форматы.
  • Первичные ключи никогда не должны меняться.
  • Не используйте номер паспорта, номер социального страхования или номер контракта сотрудника в качестве «первичного ключа», так как эти «первичные ключи» могут меняться в реальных ситуациях.

Пример:

Предположим, мы собираемся создать таблицу с именем ‘agent1’. Он содержит столбцы и типы данных, которые показаны ниже. Для каждой строки таблицы ‘agent1’ требуется идентифицировать каждого агента с помощью уникального кода, поскольку имена двух или более агентов в городе страны могут совпадать.

Так что не стоит создавать PRIMARY KEY для ‘agent_name’. ‘Agent_code’ может быть единственным и исключительным выбором для PRIMARY KEY для этой таблицы.

Имя поля Тип данных Размер Десятичные знаки НОЛЬ скованность
agent_code голец 6 нет ОСНОВНОЙ КЛЮЧ
имя агента голец 40 нет
рабочая область голец 35 да
комиссия десятичный 10 2 да
номер телефона голец 17 да

При создании таблицы вы можете включить первичный ключ, используя ограничение первичного ключа на уровне столбца или ограничение на уровне таблицы. Вот два примера на упомянутой таблице:

Ограничение первичного ключа на уровне столбца:

Код SQL:

Ограничение первичного ключа на уровне таблицы:

Код SQL:

SQL CREATE TABLE с основным ограничением

SQL PRIMARY KEY CONSTRAINT является комбинацией ограничения NOT NULL и ограничения UNIQUE. Это ограничение гарантирует, что конкретный столбец или комбинация из двух или более столбцов для таблицы имеют уникальную идентификацию, которая помогает легче и быстрее найти конкретную запись в таблице.

Пример :

В следующем примере создается таблица. Вот имя поля и типы данных:

Имя поля Тип данных Размер Десятичные знаки НОЛЬ скованность
agent_code голец 6 нет ОСНОВНОЙ КЛЮЧ
имя агента голец 40 нет
рабочая область голец 35 да
комиссия десятичный 10 2 да
номер телефона голец 17 да

можно использовать следующий оператор SQL:

Код SQL:

Чтобы увидеть структуру созданной таблицы:

Код SQL:

SQL CREATE TABLE с первичным ключом и уникальным ограничением

В следующем примере создается таблица. Вот имя поля и типы данных:

Имя поля Тип данных Размер Десятичные знаки НОЛЬ скованность
cust_code голец 6 нет ОСНОВНОЙ КЛЮЧ
CUST_NAME голец 25 нет УНИКАЛЬНАЯ
cust_city голец 25 нет
класс целое число да
agent_code голец 6 нет

можно использовать следующий оператор SQL:

Код SQL:

Чтобы увидеть структуру созданной таблицы:

Код SQL:

SQL CREATE TABLE с PRIMARY KEY CONSTRAINT для большего количества столбцов

В следующем разделе мы обсудим использование SQL PRIMARY KEY CONSTRAINT вместе с оператором CREATE TABLE для двух или более столбцов.

Пример:

В следующем примере создается таблица. Таблица должна содержать ПЕРВИЧНЫЙ КЛЮЧ с комбинацией двух столбцов ‘cust_code’ и ‘cust_city’. Вот имя поля и типы данных:

Имя поля Тип данных Размер Десятичные знаки НОЛЬ скованность
cust_code голец 6 нет ОСНОВНОЙ КЛЮЧ
CUST_NAME голец 25 нет
cust_city голец 25 нет ОСНОВНОЙ КЛЮЧ
класс целое число да
agent_code голец 6 нет

можно использовать следующий оператор SQL:

Код SQL:

Чтобы увидеть структуру созданной таблицы:

Код SQL:

Упражнения по SQL

Хотите улучшить вышеуказанную статью? Вносите свои заметки / комментарии / примеры через Disqus.

Предыдущая: Создать таблицу
Далее: Внешний ключ

Ключи SQL

ключи sql

;)

В этой статье мы попробуем рассмотреть все, что касается ключей в SQL: для чего нужны, создание, ограничения ключей. В общем: будет скучно

План на сегодня такой:

В теории реляционных баз данных — ключи это некие сущности, созданы для установления определенных ограничений, которые поддерживают целостность и доступность данных в таблицах баз данных.

Если говорить простыми словами, то ключи в sql созданы для того, чтобы указать дополнительную функциональность столбца. Будь то уникальность или то, что столбец ссылается на другую таблицу (внешний ключ).

Первичный ключ

Столбец, который в базе данных должен быть уникальным помечают первичным ключом. Первичный ключ или primary key означает, что в таблице значение колонки primary key не может повторяться. Таким образом данный ключ позволяет однозначно идентифицировать запись в таблице не боясь при этом, что значение столбца повториться. Сразу пример: допустим у Вас есть таблица пользователей. В данной таблице есть поля: ФИО, год рождения, телефон. Как идентифицировать пользователя? Таким параметрам как ФИО и телефон доверять нельзя. Ведь у нас может быть несколько пользователей не только с одинаковой фамилией, но и с именем. Телефон может меняться со временем и пользователь с номером телефона может оказаться не тем кто у нас в базе данных.

Вот для этого и придумали первичный ключ. Один раз присвоили уникальный идентификатор и все. В mySql на примере которой мы выполняем все примеры из цикла статей по SQL поле AUTO_INCREMENT нельзя задать если не указать, что это первичный ключ.

К стати, в предыдущей теме мы уже познакомились с первичным ключом: что это такое и как его создавать. Синтаксис по созданию этого ключа Вы найдете в статье Создание, изменение, удаление таблиц SQL.

Думаю, что не стоит упоминать, что поле помеченное как первичный ключ не может быть пустым при создании записи.

Внешний ключ (foreign key)

Есть еще внешний ключ (foreign key). Его еще называют ссылочным. Он нужен для связывания таблиц между собой.

усложненная модель

Если посмотреть на картинку выше, то внешним ключем будет поле поставщик в таблице обувь. Как правило, при создании таблицы задают колонку уникальных целочисленных значений. Как мы это делали когда создавали таблицу supplier.

успешное создание таблицы

Колонка supplier_id будет уникальна для каждой записи. Ее значение и будет выступать на мести колонки поставщик в таблице обувь. Предлагаю сразу и рассмотреть на примере как создается внешний ключ.

Создание внешнего ключа

создание внешнего ключа

Как видно на примере выше, синтаксис по созданию внешнего ключа довольно прост. Нужно в таблицу добавить поле, а после объявить это поле как внешний ключ и указать, куда он будет ссылаться. В данном случае поле supplier будет ссылаться на поле supplier_id в таблице supplier.

Составной ключ (composite key)

Что касается составного ключа — это несколько первичных ключей в таблице. Таким образом, создав composite key, уникальность записи будет проверяться по полям, которые объединенные в этот ключ.

Бывают ситуации, когда при вставке в таблицу нужно проверять запись на уникальность сразу по нескольким полям. Вот для этого и придуман составной ключ. Для примера я создам простую таблицу с composite key, чтобы показать синтаксис:

составной ключ

В примере выше два поля объединенные в составной ключ и в таблице не будет записей с этими одинаковыми полями.

Это все, что касается ключей в SQL. Это небольшое пособие — подготовка к статье связи sql где мы подробно рассмотрим как объединять таблицы, чтобы они составляли единую базу данных.

  • Рубрики
    • Таблица
    • Какому логическому выражению соответствует следующая таблица истинности инверсия
    • Как составить таблицу прибыли и убытков
    • Гранулометрический состав песка таблица
    • Значения синуса косинуса тангенса таблица полная
    • Таблица николай и вера куст сирени вывод

    Как создать внешние и первичные ключи MySQL: инструкция

    MySQL – это открытая реляционная система управления базами данных (СУБД), которая широко используется для хранения, управления и обработки структурированных данных. Она является одной из самых популярных и широко распространенных СУБД в мире, особенно в сфере разработки приложений и веб-сервисов.

    Работу правильно выстроенной реляционной БД невозможно представить без использования в таблицах таких структурных элементов, как первичные и внешние ключи. В настоящей статье рассмотрим предназначение этих ключей в MySQL , а также процесс их создания и удаления в таблице. Кроме того, для более детального понимания работы ключей, в конце статьи будет приведен конкретный пример их использования в БД.

    Первичный ключ и его предназначение

    Первичный ключ в MySQL – это специальный тип ограничения, который используется для идентификации записей в таблице. Он служит для обеспечения уникальности каждой строки и является основой для связи разных таблиц.

    У таких ключей есть ряд отличительных свойств:

    • Уникальность. Значения такого ключа не должны повторяться в таблице.
    • Неизменяемость. В таблице можно выделить только один столбец для такого ключа. Если пользователю требуется два и более таких полей, то он должен использовать составные ключи MySQL. В рамках данной статьи мы не будет заострять на них внимание.
    • Ненулевое значение (Not Null). Значение такого ключа не может быть нулевым ( NULL ).

    Ниже приведем пример таблицы users из некой БД, которая содержит рассматриваемый ключ:

    user_id

    username

    email

    birthdate

    registration_date

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *