Código SQL

Olá tudo bem?

Tente fazer assim

conecta.executaSql(“select * from (select * parcelamento where aluno=’”+""+JTextfieldAluno.getText()+" ') a, (select * from parcelament order by id_aluno) b order by 1");

até

Muito obg por responder @acompri noite testarei o cod mas e esse " a " e " b " oque é? order by 1? não vai dar erro?

Pq nao faz tudo de uma vez?

select * from parcelamento where aluno=X order by id_aluno

Usa um algorítimo de ordenação no código da aplicação, passando só o ID. É muito mais rápido e fácil do que ficar usando esses recursos pesados de banco de dados relacional. Se interessar, os melhores são: 1° Quick Sort, 2° Shell Sort(se for até 100 mil vetores, ele é mais rápido que o QuicK Sort) e 3° Merge Sort.

???

De qualquer forma deve ser usado um algorítimo de ordenação. O banco de dados também usaria internamente. As diferenças são que na aplicação você pode escolher qual achar mais viável(ou seja, o mais rápido), já no banco você não sabe se é insertionsort ou shellsort além de outros. Dependendo da consulta, ela já vai ser um pouco demorada, ai você ainda manda o banco ordenar. Tipo enquanto isso ele broqueia outros acessos. Até que uma ordenação por id(apesar que não vejo sentido nisso), não costuma pedir muito. Mas se fosse só buscar uma lista aleatória, seria milissegundos mais rápido, sem ter que fazer outras tarefas. Mas depende do tamanho da lista. Imagina se fosse ordenar um grande volume de dados, com base nos preços, likes ou relevância. Fácil né! Agora imagina um aplicação escalada, onde os dados vem de vários bancos diferentes.
E o mais fácil disso, é que é só copiar, colar e usar o algorítimo para qualquer tipo de lista, sem ter que ficar escrevendo diversas SQL para cada situação. Com pouco mais de 20 minutos você aprende o algorítimo e adapta a sua aplicação. Agora, eu não sei porque, mas muita gente foca mais em sql do que na programação. Buscam a solução com base nas regras do banco de dados do que com lógica de programação.

Discordo de você. Ordenar pelo banco de dados é muito mais rápido do que implementar uma ordenação em Java. Se sua aplicação está travando enquanto a ordenação não termina, separe em outra thread, deixe assincrona ou alguma outra coisa para não travar. Trazer milhoes de registros pra aplicação para depois ordenar na parte Java vai ser muito mais lento, do que fazer isso no banco de dados.

Telvez porque as Bases de Dados tem dezenas de anos de evolução com optimizações de algoritmos, totalmente orientadas para a performance, pelo que devemos reutilizar o que já alguém fez em vez de tentar partir novamente a pedra.

Quando chegares a uma empresa com uma tabela com milhões de registos, quero ver o que fazes para obteres os resultados que pretendes sem SQL e sem índices …

É olhando pelo java, realmente deve ser mais lento, por ser uma linguagem mais pesada mesmo. A Linguagem que eu uso é assíncrono e nela eu implementei o QuickSort para ordenar um vetor de 10 milhões de números em ordem decrescente para ordem crescente… e em diversos testes que fiz, o pior tempo foi de 1 segundo e 147 milésimos. Utilizei um notebook da positivo de 4GB de RAM e 64 bits que eu alterei na bios pois antes ele era 32 bits. O sistema foi Ubuntu 15.10.

Eu entendo, a mais tempo eu fazia isso também. Eu modelava as tabelas e depois ia escrevendo e referenciando as sql na aplicação. Só que depois, por questões de mais performance, eu fui removendo todos os relacionamentos de chaves estrangeira, até que eu tinha uma aplicação onde o banco só tinha o papel de criar o id automaticamente e armazenar os dados. Só, mais nada. Dai eu mudei para os NoSQL.
A minha reação ao largar os bancos relacionais e passar para os não relacionais, foi a mesma de quando eu larguei windows e passei para linux. Minha única duvida foi: porque eu não fiz isso antes?
Sem contar que os NoSQL são mais baratos pra tudo.

Com todo respeito, acho que você viajou feio nessa resposta. Primeira vez em todos meus anos de TI vejo alguém afirmar que é melhor e mais fácil (mais fácil que fazer um “order by”???!!!) ordenar uma consulta com algoritmo externo em vez de usar o próprio recurso do banco.

Em um sistema escalado é assim mesmo que é feito. Não tem como você usar recurso de bancos de dados para ordenar uma lista, onde essa lista é formada a partir de duas listas distintas, que veio de dois ou mais bancos diferentes. Essa é uma forma muito comum quando você cria uma sistema para ser escalado em varias maquinas diferentes.
E é fácil sim, é só copiar/colar e pronto, você tem uma método que recebe qualquer tipo de lista e ordena.

select * from parcelamento where aluno=’ “+JTextfieldAluno.getText()+” ’ order by id_aluno desc"
ou
select * from parcelamento where aluno=’ “+JTextfieldAluno.getText()+” ’ order by id_aluno asc"
Ordenando por:
desc = decrescente
asc = crescente

ola @jairoalmeida ate chamou o relatorio mas não ordenou corretamente tipo ele não consegue executar o order by…

não não @jairoalmeida tava passando um campo errado seu cod está correto muito obg …

Como ninguém comentou:

conecta.ExecutaSql("select * from parcelamento where aluno=’ “+JTextfieldAluno.getText()+” ’ ");

Esse tipo de código pode ser alvo de SQL injection. O ideal é sempre usar um preparedStatement pra validar as entradas. Exemplo com JDBC:

Connection dbConnection = DriverManager.getConnection("jdbc:mysql://[LOCAL]/[BANCO]?"
            + "user=[USUARIO]&password=[SENHA]");
    
    String query = "select * from parcelamento where aluno = ?";
    PreparedStatement preparedStatement = dbConnection.prepareStatement(query);
    preparedStatement.setString(1, JTextfieldAluno.
    ResultSet rs = preparedStatement.executeQuery();

Bem observado.

Pergunta.

Fez a mesma ordenação usando o banco de dados?

Qual foi o resultado do order by vs sua ordenação com (QuickSort)?

Fazendo os testes aqui, para buscar uma lista que foi ordenada no banco (OB) e para buscar uma lista desordenada e ordenar na aplicação (OA) com o ShellSort… Os resultados das quantidades de cada lista e o tempo gasto foram:

Lista de 8 posições:
OB: menor tempo 13 milisegundos e maior tempo 17 milisegundos.
OA: menor tempo 11 milisegundos e maior tempo 14 milisegundos.

Lista de 1007 posições:
OB: menor tempo 48 milisegundos e maior tempo 54 milisegundos.
OA: menor tempo 37 milisegundos e maior tempo 43 milisegundos.

Lista de 7992 posições:
OB: menor tempo 224 milisegundos e maior tempo 312 milisegundos.
OA: menor tempo 138 milisegundos e maior tempo 175 milisegundos.

Lista de 58051 posições:
OB: menor tempo 1 segundo e 283 milisegundos e maior tempo 1 segundo e 349 milisegundos.
OA: menor tempo 632 milisegundos e maior tempo 690 milisegundos.

Lembrando que eu contei o tempo a partir do inicio da busca, até a ultima linha antes de fechar a conexão com o banco.

A coluna que vc usou pra fazer a ordenação possui índice no banco?

Porque isso influenciaria na ordenação na aplicação? Na aplicação foi mais rápido.
A coluna que eu usei foi da seguinte forma: Eu tinha a coluna id, com chave em hexadecimal, a coluna com nome, que era uma string, e a coluna q, onde os valores eram inteiros que iam de 1 ate 2500, e muitos se repetiam quando a lista era maior que 2500. A coluna que eu usei para a busca, foi a coluna q. Onde a busca trazia TODOS os campos.
Uma consulta sem ordenação nenhuma, gasta numa lista de 7992 items, aproximadamente 124 milissegundos. Trazer essa mesma lista do banco, estando ordenada, gasta em média 275 milissegundos. Contando somente o tempo que o ShellSort gasta para ordenar na aplicação, é de 12 milissegundos. Com isso você pode trazer sem ordenação (124 milissegundos) e ordenar com ShellSort (12 milissegundos), resultando em um total de 124+12=136 milissegundos.
Esses dados são todos da primeira até a ultima consulta, sempre mantendo essa média. E não usei índices nenhum.

Faz outro teste.
Adiciona um índice na nessa coluna “q” e faz novamente o teste.

As consultas foram quase as mesmas(com diferença que uma tinha o orderby e a outra não). Com ou sem índice só vai interferir na velocidade da busca. Uma busca COM ordenação gasta o dobro do tempo, do que uma sem.
Em todos os casos eu repeti a consulta pelo menos 15 vezes, inclusive nessa ultima resposta eu testei agora cedo.
Nos meus testes que fiz, para ordenar vetores que estavam em ordem decrescente para a ordem crescente… O shellSort gastou 2 segundos e 600 milésimos para ordenar uma lista com 10.000.000 de items. Enquanto essa mesma lista com o QuickSort, gastou em média 1 segundo e 140 milésimos.