O uso da chave primária de auto-incremento do PostgreSQL e seu uso em mybatis

prefácio

Recentemente, no processo de migração do banco de dados do produto de MySql para PostgreSQL, na migração e adaptação da chave primária de auto-incremento do MySql para a chave primária de auto-incremento do PostgreSQL, depois de algumas reviravoltas, o problema foi finalmente resolvido através do processo de pular e sair do poço. Registro e resumo a experiência de alunos que se depararam com situações semelhantes.

O que é uma chave primária de incremento automático?

Quando definido 自增主键, a geração da chave primária é totalmente dependente do banco de dados sem intervenção humana. Quando novos dados são adicionados, os desenvolvedores não precisam definir manualmente o valor do campo de chave primária, e o banco de dados gerará automaticamente um valor de chave primária.

Por que você precisa de uma chave primária de incremento automático?

• A chave primária de auto-incremento permite que o índice da chave primária seja inserido em ordem crescente, evitando assim a divisão da página;
• Em comparação com outros tipos (como varchar), o uso de chaves primárias de incremento automático economiza a sobrecarga de armazenamento até certo ponto;
• A manutenção do programa aplicativo é relativamente simples, apenas configuração unificada é necessária no código e não há necessidade de definir manualmente o valor da chave primária;

1. O uso da chave primária de incremento automático no MySql

1. Crie uma tabela com uma chave primária de incremento automático

create table t_user(
	`id` INT NOT NULL AUTO_INCREMENT COMMENT '主键id',
	`age` INT(11) NOT NULL DEFAULT 10 COMMENT '年龄',
	PRIMARY KEY (`id`)
)

2. Como escrever SQL ao inserir dados

insert into t_user(age) values(18)
insert into t_user(age) values(20)

Consultar os dados inseridos acima

 

3. Modifique o valor inicial da chave primária de incremento automático

Em alguns casos, o aplicativo precisa que a chave primária do ID comece a partir de uma posição especificada ou maior que esse valor (por exemplo: para reservar um determinado intervalo de ID no meio), você pode usar a seguinte instrução sql com base em um tabela conhecida Ajuste

alterar tabela t_user auto_increment=10;

Em seguida, insira dois dados na tabela acima

inserir nos valores t_user(age)(24)
inserir nos valores t_user(age)(26)

Observe o efeito novamente e você descobrirá que o valor inicial de id se torna 11 neste momento

 

4. Uso de chave primária de incremento automático em mybatis

Os seguintes métodos podem ser usados ​​no processamento de mybatis na chave primária de auto-incremento

    <insert id="addUser" parameterType="com.congge.entity.TUser">
        INSERT INTO t_user
        (age)
        VALUES (
        #{age}
        )
        <selectKey keyProperty="id" resultType="java.lang.Integer" order="AFTER">
            SELECT LAST_INSERT_ID();
        </selectKey>
    </insert>

Nota Suplementar

Quando a tabela acima é construída, o incremento automático da chave primária é limitado diretamente pela construção da tabela, ou você não pode especificá-la antes de construir a tabela, mas use a instrução de alerta para modificar:

alterar tabela t_user modificar id integer auto_increment ; 

2. Uso de chave primária de auto-incremento no PostgreSQL

No PostgreSQL, o uso da chave primária de auto-incremento é um pouco diferente. Ao criar uma tabela, especifique o tipo de campo como serial para identificar o campo atual como uma chave primária de auto-incremento;

No PostgreSQL, os dois métodos a seguir podem ser usados ​​para definir uma sequência de valores crescentes de chave primária (o mysql também pode ser usado)

Pré-preparação, crie uma mesa PG comum

create table t_user(
	id INT NOT NULL ,
	age INT NOT NULL DEFAULT 10,
	PRIMARY KEY (id)
)

Método 1: Criando manualmente uma sequência para obter um efeito incremental

Crie uma sequência de incremento automático (semelhante à função no mysql) e chame essa sequência sempre que precisar obter a chave primária de incremento automático.

1. Crie uma sequência de chave primária de incremento automático

CREATE SEQUENCE 
t_user_id_seq
INCREMENT 1 -- tamanho do passo
MINVALUE 1 -- valor mínimo
MAXVALUE 9999 -- valor máximo
START WITH 1 -- valor inicial
CACHE 1; 

Depois de executar o método de sequência de criação acima, você pode consultar todas as sequências no banco de dados por meio do seguinte sql

selecione * de information_schema.sequences onde sequence_schema = 'público';

O circulado na figura é o valor da sequência que acabamos de criar acima

 

2. Chame o método de sequência de incremento automático para inserir dados

A próxima etapa é chamar os métodos relacionados da sequência e, em seguida, usá-los no sql da instrução de inserção. Se você deseja inserir dados na tabela t_user acima, pode usar a seguinte operação sq,

insert into t_user values(
	nextval('t_user_id_seq') , 18
)

insert into t_user values(
	nextval('t_user_id_seq') , 22
)

 

3. Resumo dos métodos comuns de sequência de incremento automático

Pode-se ver que os dados são inseridos na forma de auto-incremento de chave primária como esperávamos.Na instrução insert acima, o método nextval é usado, que é um dos métodos fornecidos por padrão na sequência de auto-incremento. A sequência de auto-incremento fornece referência comum Os métodos a seguir fornecem

função	tipo de retorno	Descrição
loadselect()	bigint	Retorna o valor mais recente de qualquer sequência obtida com nextval
nextval(regclass)	bigint	Incrementa uma sequência e retorna o novo valor
currval( regclass )	bigint	Obtenha o valor da sequência especificada após o último uso de netxval.Se você usar currval diretamente em vez de nextval, ocorrerá um erro.
setval(regclass,bigint,booleano)	bigint	Defina o valor atual da sequência e o sinalizador is_called. Se for verdadeiro, terá efeito imediatamente. Se for falso, terá efeito após chamar nextval uma vez
setval(regclass,bigint)	bigint	Define o valor atual da sequência

4. Defina o valor padrão da chave primária de incremento automático

O método fornecido acima descobriu que ao escrever a instrução de inserção é necessário adicionar uma função, o que é um pouco complicado, portanto, o seguinte método pode ser considerado para ajustar o valor padrão do campo ID;

Defina o valor padrão do campo id como nextval('t_user_id_seq') e adicione esta frase diretamente com base na sequência criada acima

alter table 
	t_user 
alter column 
	id  
set default nextval(
	't_user_id_seq'  
);

Ao inserir dados novamente, basta escrevê-los diretamente da seguinte maneira

insert into t_user values(
	23
)
insert into t_user values(
	24
)

Consulte os dados e descubra que eles ainda podem ser gravados com sucesso em

 

Método 2: especificando o campo como tipo serial para obter o efeito incremental

1. Use a seguinte instrução de criação de tabela

create table t_user(
	id serial NOT NULL ,
	age INT NOT NULL DEFAULT 10,
	PRIMARY KEY (id)
)

2. Visualize a sequência criada

selecione * de information_schema.sequences onde sequence_schema = 'público';

Observe que a sequência criada antes não será limpa, a menos que a instrução para limpar a sequência seja chamada manualmente. Por padrão, o nome da sequência é +id_seq. Como foi criada antes, uma seq1 é emendada automaticamente aqui, isto é, id Usando serial, o PG anexará uma sequência à tabela atual por padrão;

 

3. Insira os dados

Ao inserir dados novamente, basta escrever da seguinte maneira

insert into t_user(age) values(
	23
);
insert into t_user(age) values(
	24
);

Os dados ainda podem ser encontrados e o id é incrementado;

 

4. O uso da sequência PG em mybatis

    <insert id="addUser" parameterType="com.congge.entity.TUser">
        INSERT INTO t_user
        (age)
        VALUES (
        #{age}
        )
        <selectKey keyProperty="id" resultType="java.lang.Integer" order="AFTER">
            SELECT nextval('t_user_id_seq'::regclass) as id
        </selectKey>
    </insert>

3. Migração de dados MySql para PostgreSQL Algumas sugestões sobre auto-incremento de chave primária

Nos negócios reais, a migração no nível de dados pode ser feita primeiro. Após a conclusão da migração, o negócio pode ser usado normalmente. No entanto, após a migração dos dados, o editor descobriu que a interface relatou um erro. O principal motivo da erro foi o conflito de chave primária. Por quê? Que tal isso?

Por exemplo, o valor máximo do id de dados da tabela t_user no mysql é 99. Depois de migrar para pg, o valor máximo dos dados ainda é 99. Isso não é um problema, mas depois de cortar o banco de dados, ao usar o PG seqüência de auto-incremento para criar dados, mas a partir de 1, após a migração, os dados com ID 1 já existem e, claro, um erro será relatado;

Neste momento, é necessário fazer configurações simples para a sequência migrada. A ideia principal é a seguinte para referência:

• Use a função max para encontrar o valor máximo do ID atual: selecione max(id) de t_user;
• Ajuste manualmente o valor inicial da sequência: altere a sequência t_user_id_seq reinicie com [o valor máximo na primeira etapa ou adicione um pouco];