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

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

  • автор:

Как задать первичный ключ в SQL: подробное руководство для начинающих

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

 CREATE TABLE my_table ( id INT PRIMARY KEY, name VARCHAR(50), age INT ); 

В этом примере, мы создаем таблицу с именем my_table и тремя столбцами: id, name и age. Столбец id задан как первичный ключ с использованием ключевого слова PRIMARY KEY. Вы также можете задать составной первичный ключ, используя несколько столбцов:

 CREATE TABLE my_table ( id INT, category VARCHAR(50), PRIMARY KEY (id, category) ); 

В этом примере, мы создаем таблицу с именем my_table и двумя столбцами: id и category. Составной первичный ключ задается с использованием ключевого слова PRIMARY KEY и указанием столбцов в скобках. Надеюсь, это поможет вам задать первичный ключ в SQL!

Детальный ответ

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

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

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

CREATE TABLE table_name ( id INT PRIMARY KEY, column1 datatype, column2 datatype, . );

В этом примере, мы создаем таблицу «table_name» с полем «id» типа INT, которое будет служить первичным ключом. Остальные столбцы могут содержать любые другие типы данных по вашему выбору.

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

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

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

Здесь мы использовали команду ALTER TABLE для изменения существующей таблицы «table_name» и добавили первичный ключ, состоящий из одного или нескольких столбцов.

Примеры использования первичного ключа

Давай рассмотрим несколько примеров использования первичного ключа.

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

CREATE TABLE employees ( id INT PRIMARY KEY, first_name VARCHAR(50), last_name VARCHAR(50), email VARCHAR(100) );

В этом примере мы создаем таблицу «employees» со столбцами «id», «first_name», «last_name» и «email». Поле «id» задано как первичный ключ типа INT.

Пример 2: Добавление первичного ключа к существующей таблице

ALTER TABLE employees ADD PRIMARY KEY (id);

В этом примере мы добавляем первичный ключ к существующей таблице «employees». Первичный ключ состоит только из одного столбца «id».

Зачем нужен первичный ключ?

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

Вывод

Теперь ты знаешь, как задать первичный ключ в SQL. Помни, что правильное использование первичных ключей в базе данных является важной частью разработки и поддержки приложений. Удачи в изучении SQL! Если у тебя возникнут еще вопросы, несомненно обращайся!

Как создать два первичных ключа в SQL: Полезные советы и примеры

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

Способ 1: Использование составного первичного ключа

Составной первичный ключ состоит из нескольких столбцов, которые в совокупности обеспечивают уникальность записей. Для создания составного первичного ключа в SQL, вы можете использовать выражение CONSTRAINT вместе с ключевым словом PRIMARY KEY и перечислить столбцы, которые должны быть частью ключа. Например, если у вас есть таблица «Студенты» и вы хотите использовать два столбца «Имя» и «Фамилия» в качестве первичного ключа, вы можете использовать следующий SQL-запрос:

CREATE TABLE Students ( Имя VARCHAR(50), Фамилия VARCHAR(50), /* другие столбцы */ CONSTRAINT PK_Students PRIMARY KEY (Имя, Фамилия) );

В этом примере мы создаем таблицу «Студенты» с двумя столбцами «Имя» и «Фамилия». Затем мы используем выражение CONSTRAINT PK_Students , чтобы задать имя для первичного ключа (в данном случае «PK_Students»). Наконец, мы используем ключевое слово PRIMARY KEY и перечисляем столбцы, которые должны быть частью первичного ключа.

Способ 2: Использование двух отдельных первичных ключей

Если вам необходимо иметь два независимых первичных ключа в одной таблице, вы можете создать два отдельных первичных ключа. Для создания двух отдельных первичных ключей в SQL, вы можете использовать выражение CONSTRAINT вместе с ключевым словом PRIMARY KEY для каждого столбца. Например, если у вас есть таблица «Студенты» и вы хотите использовать столбец «ID» и столбец «Email» в качестве первичных ключей, вы можете использовать следующий SQL-запрос:

CREATE TABLE Students ( ID INT, Email VARCHAR(50), /* другие столбцы */ CONSTRAINT PK_Students_ID PRIMARY KEY (ID), CONSTRAINT PK_Students_Email PRIMARY KEY (Email) );

В этом примере мы создаем таблицу «Студенты» с двумя столбцами «ID» и «Email». Затем мы используем выражение CONSTRAINT PK_Students_ID и CONSTRAINT PK_Students_Email , чтобы задать имена для каждого первичного ключа (в данном случае «PK_Students_ID» и «PK_Students_Email»). Затем мы используем ключевое слово PRIMARY KEY и указываем соответствующие столбцы для каждого первичного ключа. Важно помнить, что при использовании нескольких первичных ключей в одной таблице вы должны быть уверены, что значения этих ключей уникальны для каждой записи. В противном случае возникнет конфликт, и SQL-запрос не будет выполнен. Надеюсь, эта информация была полезной! Если у вас возникнут еще вопросы, не стесняйтесь задавать — я всегда готов помочь. Удачи в изучении SQL!

Как задать два первичных ключа в SQL: подробное руководство

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

 CREATE TABLE my_table ( column1 INT, column2 INT, CONSTRAINT pk1 PRIMARY KEY (column1), CONSTRAINT pk2 PRIMARY KEY (column2) ); 

В данном примере мы создали таблицу с двумя столбцами ( column1 и column2 ), и задали каждому из них первичный ключ с помощью CONSTRAINT и PRIMARY KEY . Это гарантирует, что значения этих столбцов будут уникальными и не повторяются в таблице. Вы также можете добавить первичный ключ к существующей таблице с помощью оператора ALTER TABLE :

 ALTER TABLE my_table ADD CONSTRAINT pk1 PRIMARY KEY (column1), ADD CONSTRAINT pk2 PRIMARY KEY (column2); 

В этом примере мы добавили первичные ключи к таблице my_table используя оператор ALTER TABLE и указали столбцы, к которым хотим добавить первичные ключи. Обратите внимание на использование конструкции ADD CONSTRAINT для добавления первичных ключей.

Детальный ответ

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

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

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

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

 CREATE TABLE myTable ( column1 INT, column2 INT, PRIMARY KEY (column1, column2) ); 

В данном примере у нас есть таблица myTable с двумя столбцами column1 и column2 . Мы используем ключевое слово PRIMARY KEY для определения составного первичного ключа. Обратите внимание, что столбцы, входящие в составной ключ, разделяются запятой в скобках.

2. Использование отдельных первичных ключей

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

 CREATE TABLE myTable ( column1 INT, column2 INT, PRIMARY KEY (column1), CONSTRAINT pk_column2 PRIMARY KEY (column2) ); 

В данном примере у нас также есть таблица myTable с двумя столбцами column1 и column2 . Мы используем ключевое слово PRIMARY KEY для определения первичного ключа для столбца column1 , а также ключевое слово CONSTRAINT для создания отдельного первичного ключа для столбца column2 . Обратите внимание, что мы используем разные имена для этих двух первичных ключей.

3. Использование внешних ключей

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

 CREATE TABLE table1 ( id INT PRIMARY KEY ); CREATE TABLE table2 ( id INT PRIMARY KEY, table1_id INT, FOREIGN KEY (table1_id) REFERENCES table1(id) ); 

В данном примере у нас есть две таблицы table1 и table2 . Мы используем ключевое слово PRIMARY KEY для определения первичного ключа для каждой из таблиц. В таблице table2 мы также определяем внешний ключ table1_id , который ссылается на столбец id таблицы table1 с помощью ключевого слова REFERENCES . Таким образом, мы связываем две таблицы с помощью двух первичных ключей.

Заключение

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

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

При создании таблицы с реляционными данными требуется использование так называемых ключей. Они бывают первичными (primary key) и внешними. Далее предстоит разобраться с тем, как их создать и удалить.

Представленная информация пригодится всем, кто планирует работать в базе данных SQL Language и T-SQL. Она подойдет как новичкам, так и уже опытным специалистам.

Определение

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

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

Первичный ключ может быть:

  • естественным – он существует в настоящем мире (паспортные данные, фамилии и имена и так далее);
  • суррогатным – не поддерживает существование в реальности (пример – порядковый номер).

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

Особенности

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

  1. Записи, которые относятся к соответствующему первичному идентификатору, должны быть обязательно уникальными. Это значит, что, если первичные ключи состоят из одного поля, все записи в нем – неповторимые. При содержании идентификатора сразу в нескольких «областях», комбинация задействованных полей уникальна. В отдельных частях допускаются повторения.
  2. Записи в полях, которые относятся к primary key, обязательно заполняются информацией. Пустыми они быть не могут. Соответствующее ограничение в PostgreSQL носит название not null.
  3. Для каждой таблички в базе данных можно создавать всего один первичный ключ.

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

Простой и составной ключи

Простой ключ – это уникальный идентификатор, который включает в себя всего одно поле (атрибут). Он является наиболее распространенным.

Составной первичный ключ – идентификатор, состоящий из нескольких (два и более) атрибутов. Иногда он называется композитным (composite key).

Пример – личных документов одного типа с одними и теми же данными (серия и номер) не бывает. Из-за этого в отношении, содержащем сведения о людях, первичным ключом выступает только подмножество полей из типа личного документа, его серии и номера. Других вариантов нет и быть не может.

Создание

Задумываясь над тем, как создать первичный (primary) ключ в базе данных, необходимо обратить внимание на несколько операторов:

  • create table;
  • alter table.

Оба варианта подойдут для непосредственного формирования уникального идентификатора в БД. Далее предстоит изучить каждый из них более подробно.

Create table

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

  • table_name – имя таблицы, которую хочется создать;
  • pk_col1, pk_col2, …, pk_col_n – определяют составляющие первичного ключа;
  • column1, column2 – столбцы, создаваемые в БД;
  • constraint_name – название первичного ключа.

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

Alter create

Операторы языка SQL позволяют создавать первичные ключи через alter create. Этот вариант применим для ситуации, в которой таблица уже существует. Primary key в ней формируется позже.

Синтаксис будет иметь следующий вид:

  • table_name – имя таблицы, в которой будет создаваться уникальный идентификатор;
  • constraint_name – название primary key;
  • column1, column2, …, column_n – составляющие уникального идентификатора.

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

Наглядные примеры

Операторы языка SQL позволяют создавать идентификаторы таблиц несколькими способами. Первый – это через create table. Вот наглядный пример применения соответствующей концепции на практике.

В нем создан первичный ключ для таблицы suppliers. Он носит название sources_pk. Включает в себя только один столбец – supplier_id.

Выше – альтернативный синтаксис. Он подойдет при создании обычного первичного ключа для таблицы через create table. Если он составной, то для формирования такого идентификатора подойдет исключительно первый вариант. В нем ключи определены в конце оператора create table. На практике это выглядит так:

Здесь происходит создание key с именем contacts_pk. Он включает в себя комбинацию сразу нескольких столбцов. А именно – last_name и first_name. Из-за этого каждое их сочетание должно являться уникальным для таблицы contacts.

Alter table – пример

А вот еще один наглядный пример. Он позволяет сделать keys через alter table.

В заданном примере уже есть готовая таблица под названием suppliers. Primary key здесь – это sources_pk. Он формируется для ранее созданной таблицы в SQL. Включает в себя столбец supplier_id. Это – вариант всего для идентификатора всего с одним полем.

А вот – пример, который позволяет сформировать рассматриваемый компонент с несколькими «областями». В нем первичным ключом в SQL выступает supplier_pk, который содержит комбинации столбцов supplier_id, а также supplier_name.

О связи между таблицами

Предложенные ранее примеры объясняют создание идентификатора для одной таблицы. Это редкое явление в базах данных. Обычно в них несколько таблиц, связанных между собой. Первостепенной задачей, которую поддерживают «ключевые идентификаторы» — это уникальная идентификация каждой строчки. Также primary key решает еще одну задачу – связывание нескольких заданных таблиц. Для этого используются:

  • первичные ключевые элементы;
  • внешний ключ SQL.

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

  • соответствующие поля присутствуют в той таблице, на которую ссылается внешний key;
  • ссылается внешний ключ обычно на primary key другой таблицы.

В качестве наглядного примера можно взять таблицу «Ученики» — pupils. Она будет выглядеть так:

Вторая табличка – «Успеваемость» — evaluations:

В качестве первичного ключа определяют поле «ФИО» из «Ученики». Связано это с тем, что оно есть как в первом «списке», так и во втором. Оценку ученику, которого не существует, в реальной жизни поставить не получится.

Первичный ключ – это «ФИО» в «Учениках». Внешним выступит такое же поле, но из «Успеваемость». Если в первом «списке» удалить слово или какие-нибудь данные, все его оценки удаляются из второго.

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

Только в реальности такое имеет место. Поэтому приходится искать выходы из ситуации. Исправить положение помогают такие компоненты и «слова» как:

  • первичный ключ составного типа – в качестве него можно задействовать поля «ФИО», а также «Класс»;
  • суррогатный первичный идентификатор – в «Ученики» добавить поле «Номер ученика» (id int), а затем сделать его первичным;
  • добавление более уникального поля – в качестве примера допускается использование уникального номера зачетной книжки.

Запомнив все эти слова о primary в SQL, можно изучить несколько наглядных примеров реализации задачи. Они представлены здесь и тут во всех подробностях.

Удаление

Если первичный ключ больше не нужен, его можно удалить. Для этого используется оператор Atler Table:

В этом синтаксисе table_name – табличка, которую необходимо откорректировать.

Выше – наглядный пример того, как это выглядит в коде. Имя уникального идентификатора указывать не потребуется. Связано это с тем, что он у таблички может быть всего один. Система автоматически поймет, от чего необходимо избавиться.

Multiple Primary Keys in MySQL

In this tutorial, Our goal is to explore the concept of multiple primary keys of a table in MySQL. Many-a-times, businesses, and organizations must assign certain columns as the primary key.

This primary key has multiple purposes and reasons to beset its setup. It is essentially used to ensure that each column entry assigned as the primary key is unique.

If more than one column has been assigned as the primary key, then the combination of values across these should be unique. Note that a primary key cannot possess Null values in its column.

We will certainly get an error if we push or insert Null values in this column. Sometimes, it becomes necessary for organizations to get rid of this key to insert multiple similar values or null values.

The table can have more than one primary key. These additional keys are called composite primary keys .

To be precise, multiple primary keys are not assigned to columns, but multiple columns can be described while stating the primary key. Let us understand how this key works and assign multiple columns to the primary key.

Create Table Using student_details_table in MySQL

Before we begin, we create a dummy dataset to work with. Here we create a table, student_details_table , along with a few rows.

Here as we can see, we have set the stu_id and stu_firstName as the primary key for our table student_details . This would ensure that the values in this column cannot be duplicated or NULL .

The above query creates a table with rows with first and last names. To view the entries in the data, we make use of the following code.

The query mentioned above would give the following output.

Use the DESCRIBE Statement Shows the Structure of Table in MySQL

Now let us use the DESCRIBE statement and see if we have more than one column associated with the primary key.

In our case, we would need to write the following query to understand the details of the table student_details_table .

This statement would help us fetch the table’s intricate details like the data type associated with each column, different columns and their names, the keys associated with each column, and any extra information relevant to the table.

The table above shows that the fields stu_id and stu_firstName are considered primary keys.

One might need to do this because many a time, businesses need to maintain records such that there exist no duplicate combinations of certain columns.

For example, suppose a product-based company needs to limit customer orders and the number of products associated with the customer every day.

In that case, they might need to set two primary keys as customer id and product id to match the data and perform any operation necessary without any duplicate combination.

Therefore, with the help of the queries above, we can efficiently set multiple primary keys to a table in MySQL.

Preet writes his thoughts about programming in a simplified manner to help others learn better. With thorough research, his articles offer descriptive and easy to understand solutions.

Can I have multiple primary keys in a single table?

A Table can have a Composite Primary Key which is a primary key made from two or more columns. For example:

Update: Here is a link with a more detailed description of composite primary keys.

You can only have one primary key, but you can have multiple columns in your primary key.

You can also have Unique Indexes on your table, which will work a bit like a primary key in that they will enforce unique values, and will speed up querying of those values.

A table can have multiple candidate keys. Each candidate key is a column or set of columns that are UNIQUE, taken together, and also NOT NULL. Thus, specifying values for all the columns of any candidate key is enough to determine that there is one row that meets the criteria, or no rows at all.

Candidate keys are a fundamental concept in the relational data model.

It’s common practice, if multiple keys are present in one table, to designate one of the candidate keys as the primary key. It’s also common practice to cause any foreign keys to the table to reference the primary key, rather than any other candidate key.

I recommend these practices, but there is nothing in the relational model that requires selecting a primary key among the candidate keys.

This is the answer for both the main question and for @Kalmi’s question of

What would be the point of having multiple auto-generating columns?

This code below has a composite primary key. One of its columns is auto-incremented. This will work only in MyISAM. InnoDB will generate an error «ERROR 1075 (42000): Incorrect table definition; there can be only one auto column and it must be defined as a key«.

(Have been studying these, a lot)

Candidate keys — A minimal column combination required to uniquely identify a table row.
Compound keys — 2 or more columns.

  • Multiple Candidate keys can exist in a table.
    • Primary KEY — Only one of the candidate keys that is chosen by us
    • Alternate keys — All other candidate keys
      • Both Primary Key & Alternate keys can be Compound keys

      As noted by the others it is possible to have multi-column primary keys. It should be noted however that if you have some functional dependencies that are not introduced by a key, you should consider normalizing your relation.

      There can be a functional dependency between id -> name,email, street, zip_code and area But often a zip_code is associated with a area and thus there is an internal functional dependecy between zip_code -> area .

      Thus one may consider splitting it into another table:

      So that it is consistent with the third normal form.

      Primary Key is very unfortunate notation, because of the connotation of «Primary» and the subconscious association in consequence with the Logical Model. I thus avoid using it. Instead I refer to the Surrogate Key of the Physical Model and the Natural Key(s) of the Logical Model.

      It is important that the Logical Model for every Entity have at least one set of «business attributes» which comprise a Key for the entity. Boyce, Codd, Date et al refer to these in the Relational Model as Candidate Keys. When we then build tables for these Entities their Candidate Keys become Natural Keys in those tables. It is only through those Natural Keys that users are able to uniquely identify rows in the tables; as surrogate keys should always be hidden from users. This is because Surrogate Keys have no business meaning.

      However the Physical Model for our tables will in many instances be inefficient without a Surrogate Key. Recall that non-covered columns for a non-clustered index can only be found (in general) through a Key Lookup into the clustered index (ignore tables implemented as heaps for a moment). When our available Natural Key(s) are wide this (1) widens the width of our non-clustered leaf nodes, increasing storage requirements and read accesses for seeks and scans of that non-clustered index; and (2) reduces fan-out from our clustered index increasing index height and index size, again increasing reads and storage requirements for our clustered indexes; and (3) increases cache requirements for our clustered indexes. chasing other indexes and data out of cache.

      This is where a small Surrogate Key, designated to the RDBMS as «the Primary Key» proves beneficial. When set as the clustering key, so as to be used for key lookups into the clustered index from non-clustered indexes and foreign key lookups from related tables, all these disadvantages disappear. Our clustered index fan-outs increase again to reduce clustered index height and size, reduce cache load for our clustered indexes, decrease reads when accessing data through any mechanism (whether index scan, index seek, non-clustered key lookup or foreign key lookup) and decrease storage requirements for both clustered and nonclustered indexes of our tables.

      Note that these benefits only occur when the surrogate key is both small and the clustering key. If a GUID is used as the clustering key the situation will often be worse than if the smallest available Natural Key had been used. If the table is organized as a heap then the 8-byte (heap) RowID will be used for key lookups, which is better than a 16-byte GUID but less performant than a 4-byte integer.

      If a GUID must be used due to business constraints than the search for a better clustering key is worthwhile. If for example a small site identifier and 4-byte «site-sequence-number» is feasible then that design might give better performance than a GUID as Surrogate Key.

      If the consequences of a heap (hash join perhaps) make that the preferred storage then the costs of a wider clustering key need to be balanced into the trade-off analysis.

      Consider this example::

      where the tuple «(P_Id,LastName)» requires a uniqueness constraint, and may be a lengthy Unicode LastName plus a 4-byte integer, it would be desirable to (1) declaratively enforce this constraint as «ADD CONSTRAINT pk_PersonID UNIQUE NONCLUSTERED (P_Id,LastName)» and (2) separately declare a small Surrogate Key to be the «Primary Key» of a clustered index. It is worth noting that Anita possibly only wishes to add the LastName to this constraint in order to make that a covered field, which is unnecessary in a clustered index because ALL fields are covered by it.

      The ability in SQL Server to designate a Primary Key as nonclustered is an unfortunate historical circumstance, due to a conflation of the meaning «preferred natural or candidate key» (from the Logical Model) with the meaning «lookup key in storage» from the Physical Model. My understanding is that originally SYBASE SQL Server always used a 4-byte RowID, whether into a heap or a clustered index, as the «lookup key in storage» from the Physical Model.

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

      1. Sql первичный ключ что это
      2. Tempdb в sql что это
      3. В какие города можно улететь из парижа paris и сколько времени это займет sql решение
      4. Где хранятся индексы ms sql

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

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