primary - postgresql foreign key

PostgreSQL Autoincrement

Question

Estoy cambiando de MySQL a PostgreSQL y me preguntaba cómo puedo hacer valores de autoincremento. Vi en la documentación de PostgreSQL un tipo de datos "serial", pero recibo errores de sintaxis cuando lo uso (en v8.0).

Answer 1

A partir de Postgres 10, también se admiten las columnas de identidad definidas por el estándar SQL:

create table foo 
(
  id integer generated always as identity
);

crea una columna de identidad que no se puede anular a menos que se solicite explícitamente. La siguiente inserción fallará con una columna definida como generated always :

insert into foo (id) 
values (1);

Sin embargo, esto puede ser invalidado:

insert into foo (id) overriding system value 
values (1);

Cuando se usa la opción generated by default este es esencialmente el mismo comportamiento que la implementación en serial existente:

create table foo 
(
  id integer generated by default as identity
);

Cuando un valor se suministra manualmente, la secuencia subyacente también debe ajustarse manualmente, igual que con una columna en serial .

Una columna de identidad no es una clave principal de forma predeterminada (al igual que una columna en serial ). Si debería ser uno, una restricción de clave principal debe definirse manualmente.

Answer 2

De esta manera funcionará seguro, espero que ayude:

CREATE TABLE fruits(
   id SERIAL PRIMARY KEY,
   name VARCHAR NOT NULL
);

INSERT INTO fruits(id,name) VALUES(DEFAULT,''apple'');

or

INSERT INTO fruits VALUES(DEFAULT,''apple'');

Puede consultar esto en los detalles en el siguiente enlace: http://www.postgresqltutorial.com/postgresql-serial/

Answer 3

Debe tener cuidado de no insertar directamente en su SERIE o campo de secuencia, de lo contrario su escritura fallará cuando la secuencia alcance el valor insertado:

-- Table: "test"

-- DROP TABLE test;

CREATE TABLE test
(
  "ID" SERIAL,
  "Rank" integer NOT NULL,
  "GermanHeadword" "text" [] NOT NULL,
  "PartOfSpeech" "text" NOT NULL,
  "ExampleSentence" "text" NOT NULL,
  "EnglishGloss" "text"[] NOT NULL,
  CONSTRAINT "PKey" PRIMARY KEY ("ID", "Rank")
)
WITH (
  OIDS=FALSE
);
-- ALTER TABLE test OWNER TO postgres;
 INSERT INTO test("Rank", "GermanHeadword", "PartOfSpeech", "ExampleSentence", "EnglishGloss")
           VALUES (1, ''{"der", "die", "das", "den", "dem", "des"}'', ''art'', ''Der Mann küsst die Frau und das Kind schaut zu'', ''{"the", "of the" }'');


 INSERT INTO test("ID", "Rank", "GermanHeadword", "PartOfSpeech", "ExampleSentence", "EnglishGloss")
           VALUES (2, 1, ''{"der", "die", "das"}'', ''pron'', ''Das ist mein Fahrrad'', ''{"that", "those"}'');

 INSERT INTO test("Rank", "GermanHeadword", "PartOfSpeech", "ExampleSentence", "EnglishGloss")
           VALUES (1, ''{"der", "die", "das"}'', ''pron'', ''Die Frau, die nebenen wohnt, heißt Renate'', ''{"that", "who"}'');

SELECT * from test; 

Answer 4

En el contexto de la pregunta y en respuesta al comentario de @ sereja1c, la creación de SERIAL crea implícitamente secuencias, así que para el ejemplo anterior:

CREATE TABLE foo (id SERIAL,bar varchar);

CREATE TABLE crearía implícitamente la secuencia foo_id_seq para la columna serial foo.id Por lo tanto, SERIAL [4 Bytes] es bueno por su facilidad de uso a menos que necesite un tipo de datos específico para su identificación.

Answer 5

Lo sentimos, para repetir una pregunta anterior, pero esta fue la primera pregunta / respuesta de desbordamiento de pila que apareció en Google.

Esta publicación (que apareció primero en Google) habla sobre el uso de la sintaxis más actualizada para PostgreSQL 10: https://blog.2ndquadrant.com/postgresql-10-identity-columns/

que pasa a ser:

CREATE TABLE test_new (
    id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
);

Espero que ayude :)

Answer 6

Puede utilizar cualquier otro tipo de datos enteros , como smallint .

Ejemplo:

CREATE SEQUENCE user_id_seq;
CREATE TABLE user (
    user_id smallint NOT NULL DEFAULT nextval(''user_id_seq'')
);
ALTER SEQUENCE user_id_seq OWNED BY user.user_id;

Es mejor utilizar su propio tipo de datos, en lugar del tipo de datos en serie del usuario.

Answer 7

Sí, SERIAL es la función equivalente.

CREATE TABLE foo (
id SERIAL,
bar varchar);

INSERT INTO foo (bar) values (''blah'');
INSERT INTO foo (bar) values (''blah'');

SELECT * FROM foo;

1,blah
2,blah

SERIAL es solo una macro de tiempo de tabla de creación alrededor de secuencias. No puedes alterar SERIAL en una columna existente.

Answer 8

Si bien parece que las secuencias son equivalentes a MySQL auto_increment, hay algunas diferencias sutiles pero importantes:

1. Las consultas fallidas aumentan la secuencia / serie

La columna serial se incrementa en consultas fallidas. Esto lleva a la fragmentación de las consultas fallidas, no solo a la eliminación de filas. Por ejemplo, ejecute las siguientes consultas en su base de datos PostgreSQL:

CREATE TABLE table1 (
  uid serial NOT NULL PRIMARY KEY,
  col_b integer NOT NULL,
  CHECK (col_b>=0)
);

INSERT INTO table1 (col_b) VALUES(1);
INSERT INTO table1 (col_b) VALUES(-1);
INSERT INTO table1 (col_b) VALUES(2);

SELECT * FROM table1;

Deberías obtener el siguiente resultado:

 uid | col_b 
-----+-------
   1 |     1
   3 |     2
(2 rows)

Observe cómo uid va de 1 a 3 en lugar de 1 a 2.

Esto todavía ocurre si tuviera que crear manualmente su propia secuencia con:

CREATE SEQUENCE table1_seq;
CREATE TABLE table1 (
    col_a smallint NOT NULL DEFAULT nextval(''table1_seq''),
    col_b integer NOT NULL,
    CHECK (col_b>=0)
);
ALTER SEQUENCE table1_seq OWNED BY table1.col_a;

Si desea probar cómo MySQL es diferente, ejecute lo siguiente en una base de datos MySQL:

CREATE TABLE table1 (
  uid int unsigned NOT NULL AUTO_INCREMENT PRIMARY KEY,
  col_b int unsigned NOT NULL
);

INSERT INTO table1 (col_b) VALUES(1);
INSERT INTO table1 (col_b) VALUES(-1);
INSERT INTO table1 (col_b) VALUES(2);

Debe obtener lo siguiente sin fragementation :

+-----+-------+
| uid | col_b |
+-----+-------+
|   1 |     1 |
|   2 |     2 |
+-----+-------+
2 rows in set (0.00 sec)

2. La configuración manual del valor de la columna serie puede hacer que las consultas futuras fallen.

Esto fue señalado por @trev en una respuesta anterior.

Para simular esto, establezca manualmente el uid en 4, lo que "chocará" más tarde.

INSERT INTO table1 (uid, col_b) VALUES(5, 5);

Datos de la tabla:

 uid | col_b 
-----+-------
   1 |     1
   3 |     2
   5 |     5
(3 rows)

Ejecutar otro inserto:

INSERT INTO table1 (col_b) VALUES(6);

Datos de la tabla:

 uid | col_b 
-----+-------
   1 |     1
   3 |     2
   5 |     5
   4 |     6

Ahora si ejecuta otra inserción:

INSERT INTO table1 (col_b) VALUES(7);

Se producirá un error con el siguiente mensaje de error:

ERROR: el valor de la clave duplicada viola la restricción única "table1_pkey" DETALLE: la clave (uid) = (5) ya existe.

En contraste, MySQL manejará esto con gracia como se muestra a continuación:

INSERT INTO table1 (uid, col_b) VALUES(4, 4);

Ahora inserta otra fila sin configurar uid

INSERT INTO table1 (col_b) VALUES(3);

La consulta no falla, uid solo salta a 5:

+-----+-------+
| uid | col_b |
+-----+-------+
|   1 |     1 |
|   2 |     2 |
|   4 |     4 |
|   5 |     3 |
+-----+-------+

Las pruebas se realizaron en MySQL 5.6.33, para Linux (x86_64) y PostgreSQL 9.4.9

Answer 9

Si desea agregar una secuencia a id en la tabla que ya existe, puede usar:

CREATE SEQUENCE user_id_seq;
ALTER TABLE user ALTER user_id SET DEFAULT NEXTVAL(''user_id_seq'');