Bom dia pessoal sou novo aqui no fórum, estou criando um cadastro de cliente onde meu código é auto_increment, cada vez que cadastro um cliente o auto_increment sobre pra 1,2,3,4 e assim por diante, so que quando eu excluo um cliente e vou gravar outro o auto_increment também sobe por exemplo:
Gravei a maria e ela ficou com o código 3, dai eu exclui o cadastro dela, o problema é que quando vou cadastrar o próximo o auto_increment ja está em 4 e simplesmente fico sem cadastrar o código três, e única forma de você voltar o auto_increment é modificando no banco de dados, só que se toda vez q eu excluir um cliente tiver que mudar o auto_increment vai ficar meio trabalhoso para os meus funcionários que não sabem mexer muito e gasta um pouco de tempo, eu até consegui fazer voltar o auto increment mas só para um código específico por exemplo de 4 para 3: eu queria que ele diminuísse 1 e voltasse pro anterior toda vez que eu excluísse: o que eu fiz foi o sequinte:
public static String excluirCurso(int eCodigo) {
conecta();
try {
stm = con.createStatement();
String SQL = "Delete from Curso where Codigo=" + eCodigo;
String SQLE = "ALTER TABLE Curso AUTO_INCREMENT =3";
stm.execute(SQL);
stm.execute(SQLE);
stm.execute("Commit");
} catch (Exception e) {
System.out.print(e);
}
desconecta();
return null;
}
Eu queria que ao invés dele voltar a ser 3 ele diminuíssei 1 sempre por exemplo ALTER TABLE Curso AUTO_INCREMENT = -1 algo assim
Desde já muito obrigado a quem puder me ajudar! Abraço
Entendi, você quer ter um auto-increment mas que reaproveitasse códigos. Isso normalmente não é desejável na maior parte das aplicações, porque reaproveitar um código pode ocasionar muitos problemas de coerência interna nos seus dados, ou então de concorrência - um banco de dados que deva funcionar com a máxima velocidade não pode reaproveitar códigos.
Se você precisa porque precisa porque precisa, então não use um auto-increment; crie uma consulta no seu banco que retorne sempre um número de acordo com o que você quer. Não diga que não avisei.
Exatamente o que pensei agora, era so não criar com alto increment!
por que pensando melhor se eu tivesse 20 funcionários cadastrados e quisesse excluir o 5 funcionario o autoincrement ia voltar pra 5 ao invés de ir para o 21 e ia dar problema nos dados
mas mesmo assim obrigado vlw
Concordo com os dois!
muito obrigado pelo esclarecimento,
e que nem você disse wellington caso eu queria usar com auto_increment eu deveria utilizar um select que jogasse o próximo código a ser cadastrado! como por exemplo no próximo código sempre gravar com o último código excluído, e depois voltasse a gravar normalmente mas poderia ocasionar vários problemas
mas como vocês disseram é melhor trabalhar sem auto_increment senão pode dar problemas de coerência etc
vlw obrigado a todos
No tempo em que o pessoal não se interessava muito por rapidez e multiprocessamento (digamos um MS-Access com um único usuário) e que você não tinha campos com auto-incremento, as pessoas usavam um SELECT MAX (campo) + 1 para obter o próximo valor. Mas isso, como foi visto, é problemático se você tiver vários usuários ao mesmo tempo no mesmo banco, consultando e usando a mesma tabela; isso porque durante o tempo em que você vai dar um SELECT MAX(campo) + 1 e depois vai usar esse valor, pode ocorrer de alguém também pegar esse mesmo valor, o que vai acabar dando problemas do tipo “chave duplicada” ou coisas piores.
Não, não, não, você não entendeu direito: é melhor trabalhar COM auto_increment, e aceitar que você não faça o reaproveitamento de códigos. (Imagine se o Fernandinho Beira-Mar fosse morto e seu número de RG ou de CPF fosse reaproveitado quando seu filho, ou você mesmo, fosse pegar uma carteira de identidade ou o CPF. Isso não iria dar um monte de dores de cabeça para você? Hein?
Extamente resolvi continuar com auto_increment mas sem reaproveitar código! isso falicita porque senão teria que fazer uma select pra jogar o próximo código ao invés de digitar
com o auto_increment não preciso me preocupar com isso
obrigado a todos!
Concordo com o Thingol. No seu caso, não é adequado o auto-increment.
No teu exemplo, você está observando somente a remoção do último cliente cadastrado, mas e se você tivesse:
1- cliente 1
2- cliente 2
3- cliente 3
4- cliente 4
E quisesse remover (delete) o cliente 2?
cliente 3 passaria a ter o código 2 e cliente 4 o código 3? Ou continuaria de onde o autoincrement parou (ficando o “furo” na sequência de código)?
Se o impacto for baixo, é preferível um select que te traga o próximo código não utilizado (avalie com muito critério se o cadastro de cliente for feito paralelo - por 2 ou mais usuários ao mesmo tempo - pois terá que fazer alguma “reserva” do código_de_cliente antes de redisponibilizá-lo).