|
Ter uma tabela com ordem sempre mantida
Olá a todos, Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a linha do topo após ordenar por uma certa coluna. Isso se repete em todas iterações, e como faço atualizações nessa tabela (é uma "priority queue", para quem é familiarizado com notação matemática...) no intermédio, não possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente... Preciso reordenar sempre.
Acontece que isso leva algum tempo e eu preciso melhorar a performance do meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu orientador me comentou que poderíamos ter as posições pré-definidas e fazer atualizações "inteligentes", mantendo cada registro na devida posição que deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então, saber se alguém tem alguma idéia de como se pode fazer algo assim?
Desde já agradeço. Rodrigo Sperb
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
2009/10/26 Rodrigo Sperb < rodrigosperb@...>:
> Olá a todos,
>
> Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
> linha do topo após ordenar por uma certa coluna. Isso se repete em todas
> iterações, e como faço atualizações nessa tabela (é uma "priority queue",
> para quem é familiarizado com notação matemática...) no intermédio, não
> possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente...
> Preciso reordenar sempre.
>
> Acontece que isso leva algum tempo e eu preciso melhorar a performance do
> meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
> orientador me comentou que poderíamos ter as posições pré-definidas e fazer
> atualizações "inteligentes", mantendo cada registro na devida posição que
> deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então,
> saber se alguém tem alguma idéia de como se pode fazer algo assim?
>
No PostgreSQL não existe garantia de qualquer tipo de ordenação dos
dados recuperados a não ser utilizando a cláusula ORDER BY.
Seu caso parece ser bastante específico. Se o que deseja é recuperar o
último registro incluído ou alterado *talvez* a coluna do sistema ctid
possa ajudá-lo:
http://www.postgresql.org/docs/current/interactive/ddl-system-columns.htmlOsvaldo
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Olá 2009/10/26 Osvaldo Kussama <osvaldo.kussama@...>
2009/10/26 Rodrigo Sperb <rodrigosperb@...>:
> Olá a todos,
>
> Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
> linha do topo após ordenar por uma certa coluna. Isso se repete em todas
> iterações, e como faço atualizações nessa tabela (é uma "priority queue",
> para quem é familiarizado com notação matemática...) no intermédio, não
> possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente...
> Preciso reordenar sempre.
>
> Acontece que isso leva algum tempo e eu preciso melhorar a performance do
> meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
> orientador me comentou que poderíamos ter as posições pré-definidas e fazer
> atualizações "inteligentes", mantendo cada registro na devida posição que
> deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então,
> saber se alguém tem alguma idéia de como se pode fazer algo assim?
>
dados recuperados a não ser utilizando a cláusula ORDER BY.
Seu caso parece ser bastante específico. Se o que deseja é recuperar o
último registro incluído ou alterado *talvez* a coluna do sistema ctid
possa ajudá-lo:
http://www.postgresql.org/docs/current/interactive/ddl-system-columns.html
Ou você pode criar uma coluna especifica e referenciar o que procura. Como o Osvaldo falou é um caso bem específico. -- Marcelo Costa www.marcelocosta.net
------------------------------------------------- “You can't always get what want”, Doctor House in apology to Mike Jagger
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Talvez clusterizar um índice nesta tabela ajude no desempenho, já que os dados serão reorganizados a cada registro gravado [1]. Assim, a ordem retornada será sempre a mesma de um ORDER BY sobre a mesma coluna. Na verdade não sei muito o que dizer, isso foi um *chute*. Fica um tanto abstrato tentar dar alguma opinião sem um exemplo. Se puder exemplificar alguma coisa seria mais fácil.
[1] http://www.postgresql.org/docs/8.4/static/sql-cluster.html-- TIAGO J. ADAMI http://www.adamiworks.com
2009/10/26 Rodrigo Sperb <rodrigosperb@...>
Olá a todos,
Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a linha do topo após ordenar por uma certa coluna. Isso se repete em todas iterações, e como faço atualizações nessa tabela (é uma "priority queue", para quem é familiarizado com notação matemática...) no intermédio, não possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente... Preciso reordenar sempre.
Acontece que isso leva algum tempo e eu preciso melhorar a performance do meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu orientador me comentou que poderíamos ter as posições pré-definidas e fazer atualizações "inteligentes", mantendo cada registro na devida posição que deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então, saber se alguém tem alguma idéia de como se pode fazer algo assim?
Desde já agradeço.
Rodrigo Sperb
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Rodrigo, boa tarde... Não entendi bem qual o teu problema. Com relação ao algoritmo para a fila de prioridades, você já implementou? A performance foi prejudicada na reorganização dos registros após alteração nos dados? Qual algoritmo/formato de índice você está utilizando? Já tentou utilizar uma tabela em memória?
De detalhes do problema, pois ficou um pouco vago. Att, -- Charly Frankl http://javadevilopers.blogspot.com/charlyfrankl@...
Linux user #391083 "Se
você tem uma maçã e eu tenho uma maçã e nós trocamos essas maçãs, então
eu e você ainda teremos uma maçã cada. Mas se você tiver uma idéia e eu
tiver uma idéia e nós trocamos idéias, então cada um de nós terá duas
idéias." George Bernard Shaw (1856-1950) 2009/10/26 Rodrigo Sperb <rodrigosperb@...>
Olá a todos,
Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a linha do topo após ordenar por uma certa coluna. Isso se repete em todas iterações, e como faço atualizações nessa tabela (é uma "priority queue", para quem é familiarizado com notação matemática...) no intermédio, não possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente... Preciso reordenar sempre.
Acontece que isso leva algum tempo e eu preciso melhorar a performance do meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu orientador me comentou que poderíamos ter as posições pré-definidas e fazer atualizações "inteligentes", mantendo cada registro na devida posição que deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então, saber se alguém tem alguma idéia de como se pode fazer algo assim?
Desde já agradeço.
Rodrigo Sperb
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
 Re: Ter uma tabela com ordem sempre mantida
Olá Pessoal,
Obrigado pelo esforço em ajudar, eu entendo que talvez ficou um tanto vago para entender. Vou tentar explicar melhor:
É um algoritmo para resolver um "time-dependent shortest path" baseado no famoso Dijkstra para shortest path, mas que realiza um "refinamento" do tempo, determinando funções de tempo de chegada (contra tempo de saída) para cada "node" (vértice) do grafo. A incialização do algoritmo define tempo de chegada igual tempo de saída para o vértice de saída, e "infinito" para todos os outros... Aí o algoritmo inicia retirando da fila o vértice de saída e atualiza o tempo de chegada para os vértices vizinhos nos quais finalizam arcos que saem do vértice de saída, usando o delay que é uma funçãod o tempo conhecida para cada arco...
A fila de prioridade é então atualizada com valores atualizados.... Aí é que começa realmente o problema que mencionei. Quando atualizo, óbvio que vai para o final da tabela. Então para manter a fila de prioridade coerente (menores tempos de chegada acima!), tenho que reordenar. Como disse, meu orientador comentou que seria possível fazer "smart updates" que já colocariam os valores nos devidos lugares (para a fila de prioridade), então estava imaginando como, e talvez alguém tenha uma idéia...
Atenciosamente,
Rodrigo Sperb
----------------------------------------------------------------------
Message: 1
Date: Mon, 26 Oct 2009 12:07:17 -0200
From: Osvaldo Kussama <osvaldo.kussama@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<690707f60910260707u586d84e0ybd7f79c8bbf40b58@...>
Content-Type: text/plain; charset=ISO-8859-1
2009/10/26 Rodrigo Sperb <rodrigosperb@...>:
> Olá a todos,
>
> Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
> linha do topo após ordenar por uma certa coluna. Isso se repete em todas
> iterações, e como faço atualizações nessa tabela (é uma "priority queue",
> para quem é familiarizado com notação matemática...) no intermédio, não
> possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente...
> Preciso reordenar sempre.
>
> Acontece que isso leva algum tempo e eu preciso melhorar a performance do
> meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
> orientador me comentou que poderíamos ter as posições pré-definidas e fazer
> atualizações "inteligentes", mantendo cada registro na devida posição que
> deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então,
> saber se alguém tem alguma idéia de como se pode fazer algo assim?
>
No PostgreSQL não existe garantia de qualquer tipo de ordenação dos
dados recuperados a não ser utilizando a cláusula ORDER BY.
Seu caso parece ser bastante específico. Se o que deseja é recuperar o
último registro incluído ou alterado *talvez* a coluna do sistema ctid
possa ajudá-lo:
http://www.postgresql.org/docs/current/interactive/ddl-system-columns.html
Osvaldo
------------------------------
Message: 2
Date: Mon, 26 Oct 2009 12:16:27 -0200
From: Marcelo Costa <marcelojscosta@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<c13f2d590910260716v747a2c69rdf343f8e8432880@...>
Content-Type: text/plain; charset="windows-1252"
Olá
2009/10/26 Osvaldo Kussama <osvaldo.kussama@...>
> 2009/10/26 Rodrigo Sperb <rodrigosperb@...>:
> > Olá a todos,
> >
> > Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
> > linha do topo após ordenar por uma certa coluna. Isso se repete em todas
> > iterações, e como faço atualizações nessa tabela (é uma "priority queue",
> > para quem é familiarizado com notação matemática...) no intermédio, não
> > possa ter a ordenação pré-estabelecida e sempre pegar o topo
> simplesmente...
> > Preciso reordenar sempre.
> >
> > Acontece que isso leva algum tempo e eu preciso melhorar a performance do
> > meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
> > orientador me comentou que poderíamos ter as posições pré-definidas e
> fazer
> > atualizações "inteligentes", mantendo cada registro na devida posição que
> > deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria,
> então,
> > saber se alguém tem alguma idéia de como se pode fazer algo assim?
> >
>
>
> No PostgreSQL não existe garantia de qualquer tipo de ordenação dos
> dados recuperados a não ser utilizando a cláusula ORDER BY.
>
> Seu caso parece ser bastante específico. Se o que deseja é recuperar o
> último registro incluído ou alterado *talvez* a coluna do sistema ctid
> possa ajudá-lo:
> http://www.postgresql.org/docs/current/interactive/ddl-system-columns.html
>
>
Ou você pode criar uma coluna especifica e referenciar o que procura.
Como o Osvaldo falou é um caso bem específico.
--
Marcelo Costa
www.marcelocosta.net
-------------------------------------------------
?You can't always get what want?,
Doctor House in apology to Mike Jagger
-------------- Próxima Parte ----------
Um anexo em HTML foi limpo...
URL: http://listas.postgresql.org.br/pipermail/pgbr-geral/attachments/20091026/c90340f9/attachment-0001.htm
------------------------------
Message: 3
Date: Mon, 26 Oct 2009 13:38:17 -0200
From: Tiago Adami <adamitj@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<950f30a10910260838p55de6c3dmfe92595ea09ec84@...>
Content-Type: text/plain; charset="utf-8"
Talvez clusterizar um índice nesta tabela ajude no desempenho, já que os
dados serão reorganizados a cada registro gravado [1]. Assim, a ordem
retornada será sempre a mesma de um ORDER BY sobre a mesma coluna.
Na verdade não sei muito o que dizer, isso foi um *chute*. Fica um tanto
abstrato tentar dar alguma opinião sem um exemplo. Se puder exemplificar
alguma coisa seria mais fácil.
[1] http://www.postgresql.org/docs/8.4/static/sql-cluster.html
--
TIAGO J. ADAMI
http://www.adamiworks.com
2009/10/26 Rodrigo Sperb <rodrigosperb@...>
> Olá a todos,
>
> Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
> linha do topo após ordenar por uma certa coluna. Isso se repete em todas
> iterações, e como faço atualizações nessa tabela (é uma "priority queue",
> para quem é familiarizado com notação matemática...) no intermédio, não
> possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente...
> Preciso reordenar sempre.
>
> Acontece que isso leva algum tempo e eu preciso melhorar a performance do
> meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
> orientador me comentou que poderíamos ter as posições pré-definidas e fazer
> atualizações "inteligentes", mantendo cada registro na devida posição que
> deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então,
> saber se alguém tem alguma idéia de como se pode fazer algo assim?
>
> Desde já agradeço.
>
> Rodrigo Sperb
>
> _______________________________________________
> pgbr-geral mailing list
> pgbr-geral@...
> https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
>
>
-------------- Pr?a Parte ----------
Um anexo em HTML foi limpo...
URL: http://listas.postgresql.org.br/pipermail/pgbr-geral/attachments/20091026/bd3a309a/attachment-0001.htm
------------------------------
Message: 4
Date: Mon, 26 Oct 2009 13:09:16 -0300
From: Tarcísio Sassara <sassara.tarcisio@...>
Subject: Re: [pgbr-geral] Sincronizar bancos de dados
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<cff879ab0910260909v6d27a980p4f99b78de5e82239@...>
Content-Type: text/plain; charset=ISO-8859-1
2009/10/26 Professador de Idéias <professador@...>:
> Tarcísio,
> como são estes stored procedures? os dados são gravados em tabelas normais?
Sim, é copiar das tabelas dos notebooks e inserir nas tabelas da
respectiva filial.
> como é que ele sabe que este dado de ser enviado e o que já foi gravado na
> filial não deve ser mandando?
> explique melhor..
Ai você deve montar um esquema para saber se uma venda é nova.
Por exemplo: Se o vendedor sai as 08:00 da filial no dia 25, todos os
registros inseridos
a partir daquela data serão novos. O vendedor poderá ficar dias fora e
quando voltar, vai inserir
no banco da filial todos os dados a partir da data de sua saída.
Criando uma stored procedure, você
pode passar como parâmetro a data em que deve começa a contar como nova venda.
Atenção!
Se o vendedor pode _*alterar*_ dados e não apenas _*incluir*_ novos, o
processo fica mais
complicado. Por exemplo:
O vendedor ao atender um cliente precisa alterar o telefone de contato dele.
Neste caso, o registro do cliente já existe na filial, então, você não
poderá inserir direto, deverá fazer um update. Mas como vai saber se
pode fazer este update? Talvez, neste tempo em que o vendedor atendia
o cliente, outra pessoa alterou outros dados deste mesmo cliente.
O update é mais problemático.
Pode ser necessário criar uma tabela intermediaria no banco para
armazenar e comparar os registros
para saber se é seguro fazer a atualização.
Sobre a procedure:
O dblink é um contrib do postgresql que lhe permite conectar a outro
banco de dados.
Então a procedure pode fazer o seguinte trabalho usando o dblink:
CREATE FUNCTION sincroniza(data_inicial date) ...
DECLARE
venda record;
BEGIN
-- conecta no banco da filial
select dblink_connect('filial', 'dbname=filial');
FOR venda IN SELECT *
FROM vendas
WHERE data > data_inicial LOOP
-- para cada venda no notebook insere na filial
select dblink_exec('filial', 'insert into vendas values ......');
END LOOP;
select dblink_close('filial');
END;
Se tiver duvidas, tente escrever um pouco mais sobre para podermos ajudar.
--
Tarcisio F. Sassara
------------------------------
Message: 5
Date: Mon, 26 Oct 2009 14:24:28 -0200
From: Charly Frankl <carlbsb@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<41fe1bee0910260924r344c7967m420fb845d2d3457a@...>
Content-Type: text/plain; charset="iso-8859-1"
Rodrigo, boa tarde...
Não entendi bem qual o teu problema. Com relação ao algoritmo para a fila de
prioridades, você já implementou? A performance foi prejudicada na
reorganização dos registros após alteração nos dados? Qual algoritmo/formato
de índice você está utilizando? Já tentou utilizar uma tabela em memória?
De detalhes do problema, pois ficou um pouco vago.
Att,
--
Charly Frankl
http://javadevilopers.blogspot.com/
charlyfrankl@...
Linux user #391083
"Se você tem uma maçã e eu tenho uma maçã e nós trocamos essas maçãs, então
eu e você ainda teremos uma maçã cada. Mas se você tiver uma idéia e eu
tiver uma idéia e nós trocamos idéias, então cada um de nós terá duas
idéias."
George Bernard Shaw (1856-1950)
2009/10/26 Rodrigo Sperb <rodrigosperb@...>
> Olá a todos,
>
> Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
> linha do topo após ordenar por uma certa coluna. Isso se repete em todas
> iterações, e como faço atualizações nessa tabela (é uma "priority queue",
> para quem é familiarizado com notação matemática...) no intermédio, não
> possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente...
> Preciso reordenar sempre.
>
> Acontece que isso leva algum tempo e eu preciso melhorar a performance do
> meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
> orientador me comentou que poderíamos ter as posições pré-definidas e fazer
> atualizações "inteligentes", mantendo cada registro na devida posição que
> deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então,
> saber se alguém tem alguma idéia de como se pode fazer algo assim?
>
> Desde já agradeço.
>
> Rodrigo Sperb
>
> _______________________________________________
> pgbr-geral mailing list
> pgbr-geral@...
> https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
>
>
-------------- Próxima Parte ----------
Um anexo em HTML foi limpo...
URL: http://listas.postgresql.org.br/pipermail/pgbr-geral/attachments/20091026/3ef9e486/attachment-0001.htm
------------------------------
Message: 6
Date: Mon, 26 Oct 2009 10:13:04 -0700 (PDT)
From: paulo matadr <saddoness@...>
Subject: [pgbr-geral] Ambiente Replicação
To: pgbr_LISTA <pgbr-geral@...>
Message-ID: <100893.59750.qm@...>
Content-Type: text/plain; charset="iso-8859-1"
Pessoal.
To querendo montar um laboratorio virtual pra testa ferramentas de replicação,meu interesse e criar a seguinte estrutura.
MASTER ( com insert,update,delete) replicando sicronamente pra 2 slaves readonly.
qual a ferramenta de replicação mais recomendada e robusta que vcs possam me indicar.
att
____________________________________________________________________________________
Veja quais são os assuntos do momento no Yahoo! +Buscados
http://br.maisbuscados.yahoo.com
-------------- Próxima Parte ----------
Um anexo em HTML foi limpo...
URL: http://listas.postgresql.org.br/pipermail/pgbr-geral/attachments/20091026/10fdfc78/attachment.htm
------------------------------
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
Fim da Digest pgbr-geral, volume 32, assunto 81
***********************************************
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Fala, acho que o que ele pensou seria você "inserir" essa prioridade (criar uma coluna mesmo) e ir somente atualizando essa coluna. o seu algoritmo precisa dessa fila ordenada para funcionar?
[]'s Luigi Castro Cardeles
2009/10/26 Rodrigo Sperb <rodrigosperb@...>
Olá Pessoal,
Obrigado pelo esforço em ajudar, eu entendo que talvez ficou um tanto vago para entender. Vou tentar explicar melhor:
É um algoritmo para resolver um "time-dependent shortest path" baseado no famoso Dijkstra para shortest path, mas que realiza um "refinamento" do tempo, determinando funções de tempo de chegada (contra tempo de saída) para cada "node" (vértice) do grafo. A incialização do algoritmo define tempo de chegada igual tempo de saída para o vértice de saída, e "infinito" para todos os outros... Aí o algoritmo inicia retirando da fila o vértice de saída e atualiza o tempo de chegada para os vértices vizinhos nos quais finalizam arcos que saem do vértice de saída, usando o delay que é uma funçãod o tempo conhecida para cada arco...
A fila de prioridade é então atualizada com valores atualizados.... Aí é que começa realmente o problema que mencionei. Quando atualizo, óbvio que vai para o final da tabela. Então para manter a fila de prioridade coerente (menores tempos de chegada acima!), tenho que reordenar. Como disse, meu orientador comentou que seria possível fazer "smart updates" que já colocariam os valores nos devidos lugares (para a fila de prioridade), então estava imaginando como, e talvez alguém tenha uma idéia...
Atenciosamente,
Rodrigo Sperb
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Olá, Tiago O custo disso é que para cada inserção é necessário clusterizar novamente a tabela a partir do índice, pois a cada inserção é provável que o registro vá para o final da tabela.
2009/10/26 Tiago Adami <adamitj@...>
Talvez clusterizar um índice nesta tabela ajude no desempenho, já que os dados serão reorganizados a cada registro gravado [1]. Assim, a ordem retornada será sempre a mesma de um ORDER BY sobre a mesma coluna.
Na verdade não sei muito o que dizer, isso foi um *chute*. Fica um tanto abstrato tentar dar alguma opinião sem um exemplo. Se puder exemplificar alguma coisa seria mais fácil.
[1] http://www.postgresql.org/docs/8.4/static/sql-cluster.html
--
TIAGO J. ADAMI
http://www.adamiworks.com
Olá a todos,
Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a linha do topo após ordenar por uma certa coluna. Isso se repete em todas iterações, e como faço atualizações nessa tabela (é uma "priority queue", para quem é familiarizado com notação matemática...) no intermédio, não possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente... Preciso reordenar sempre.
Acontece que isso leva algum tempo e eu preciso melhorar a performance do meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu orientador me comentou que poderíamos ter as posições pré-definidas e fazer atualizações "inteligentes", mantendo cada registro na devida posição que deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então, saber se alguém tem alguma idéia de como se pode fazer algo assim?
Desde já agradeço.
Rodrigo Sperb
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
[]s -- JotaComm http://jotacomm.wordpress.com
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Certo JotaComm, concordo com sua posição, mas durante a minha sugestão não tinha informações para dar a melhor solução. Mas continuando, a questão que me veio à cabeça inicialmente é de quantos registros existem no universo deste problema, e em qual intervalo de tempo a fila recebe ou perde registros que exijam uma nova reorganização.
Como não sabemos ainda se o desempenho é baixo na execução da função de ordenação ou durante a atualização dos registros na tabela (Rodrigo por favor nos diga) eu sugeri a criação do índice clusterizado. Porém, após reler os posts do Rodrigo, me veio à cabeça uma solução que encontrei muito tempo atrás para resolver um problema parecido, onde a cada nova linha inserida era necessário reorganizar quase todos os registros de uma tabela de "chamados", que possuíam um número único de prioridade na fila determinando a ordem de atendimento.
Nesta ocasião eu utilizava uma pesquisa binária começando do fim ao início da fila para encontrar em qual parte o registro seria encaixado. Após isto, todos os registros do ponto de inserção até o início da fila eram atualizados para receber o novo valor de prioridade (maior prioridade, início da fila). Exemplo:
Prioridade, Registro 8, A 7, B 6, C 5, D 4, E 3, F 2, G 1, H Inserindo registro BA com prioridade 7 (valor definido pelo aplicativo segundo regras pré-estabelecidas): Neste caso pesquisaria: BA >= H, depois BA >= D e por fim BA >= B, sendo este último a condição satisfatória da pesquisa binária. Então ficaria:
Prioridade, Registro
8, A
7, B 7, BA -- O registro entrou aqui
6, C
5, D
4, E
3, F
2, G
1, H
Mas o campo "prioridade" não poderia ter valores repetidos, então era feito um algoritmo de atualização para recalcular a prioridade de todos que no final resultava: Prioridade, Registro
9, A
8, BA -- por ser mais recente, passou à frente do registro "B" (regra de negócio)
7, B
6, C
5, D
4, E
3, F
2, G
1, H
O problema disso tudo era que o número de registros na fila beirava os 1.000 (isso mesmo, hum mil), mas como a tabela possuía um grande número de colunas indexadas e triggers disparadas a cada update, a atualização direta era muito lenta. Bolei então uma solução bem simples para o problema, criando uma tabela auxiliar chamada "chamado_prioridade" que mantinha apenas as colunas "Prioridade" e "Registro" (que na verdade tinha outro nome e era a chave primária da tabela de chamados).
A stored procedure era executada, e cada registro reorganizado era gravado em uma tabela temporária, idêntica à "chamado_prioridade". Após reorganizar todos os registros, o processo finalizava com: DELETE FROM chamado_prioridade;
INSERT INTO chamado_prioridade( prioridade, registro ) SELECT prioridade, registro FROM chamado_prioridade_tmp; DROP TABLE chamado_prioridade_tmp; E isso deu um ganho de tempo antes inimaginável no processo, pois em média a cada 5 minutos um novo chamado entrava na fila.
Bem, por mais ridículo que esta minha "solução" possa ser, espero que alguma idéia possa ser aproveitada. Não sei como esta solução se comportaria com milhares ou milhões de registros... P.S: Quando um chamado era atendido, ele era removido da fila (causando nova reorganização). Ou seja, o tamanho da fila nunca seria de 0 para o infinito, variava entre 1 e pouco mais de 1000.
-- TIAGO J. ADAMI http://www.adamiworks.com2009/11/5 JotaComm <jota.comm@...>
Olá, Tiago
O custo disso é que para cada inserção é necessário clusterizar novamente a tabela a partir do índice, pois a cada inserção é provável que o registro vá para o final da tabela.
2009/10/26 Tiago Adami <adamitj@...>
Talvez clusterizar um índice nesta tabela ajude no desempenho, já que os dados serão reorganizados a cada registro gravado [1]. Assim, a ordem retornada será sempre a mesma de um ORDER BY sobre a mesma coluna.
Na verdade não sei muito o que dizer, isso foi um *chute*. Fica um tanto abstrato tentar dar alguma opinião sem um exemplo. Se puder exemplificar alguma coisa seria mais fácil.
[1] http://www.postgresql.org/docs/8.4/static/sql-cluster.html
--
TIAGO J. ADAMI
http://www.adamiworks.com
Olá a todos,
Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a linha do topo após ordenar por uma certa coluna. Isso se repete em todas iterações, e como faço atualizações nessa tabela (é uma "priority queue", para quem é familiarizado com notação matemática...) no intermédio, não possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente... Preciso reordenar sempre.
Acontece que isso leva algum tempo e eu preciso melhorar a performance do meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu orientador me comentou que poderíamos ter as posições pré-definidas e fazer atualizações "inteligentes", mantendo cada registro na devida posição que deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então, saber se alguém tem alguma idéia de como se pode fazer algo assim?
Desde já agradeço.
Rodrigo Sperb
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Tiago Adami escreveu:
> Mas continuando, a questão que me veio à cabeça inicialmente é de
> quantos registros existem no universo deste problema, e em qual
> intervalo de tempo a fila recebe ou perde registros que exijam uma nova
> reorganização.
>
Por que não utilizar simplesmente o _fillfactor_? Manter uma tabela ordenada é
uma tarefa árdua (principalmente se essa tabela sofre muitas modificações).
--
Euler Taveira de Oliveira
http://www.timbira.com/_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Euler, Desculpa a ignorância, mas o que é o _fillfactor_? 2009/11/7 Euler Taveira de Oliveira <euler@...>
Tiago Adami escreveu:
> Mas continuando, a questão que me veio à cabeça inicialmente é de
> quantos registros existem no universo deste problema, e em qual
> intervalo de tempo a fila recebe ou perde registros que exijam uma nova
> reorganização.
>
Por que não utilizar simplesmente o _fillfactor_? Manter uma tabela ordenada é
uma tarefa árdua (principalmente se essa tabela sofre muitas modificações).
--
Euler Taveira de Oliveira
http://www.timbira.com/
-- André de Camargo Fernandes
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
|
Re: Ter uma tabela com ordem sempre mantida
Tiago, Algo como sua idéia poderia servir. Por agora, tenho outros problemas para resolver na funcão, e estou deixando esse de lado, e simplesmente reordenando a cada iteração (não é o principal bottleneck em termos de performance, de qualquer forma...).
Agradeço muito as sugestões dadas. Atenciosamente, Rodrigo Sperb 2009/11/7 <pgbr-geral-request@...>
Send pgbr-geral mailing list submissions to
pgbr-geral@...
To subscribe or unsubscribe via the World Wide Web, visit
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
or, via email, send a message with subject or body 'help' to
pgbr-geral-request@...
You can reach the person managing the list at
pgbr-geral-owner@...
When replying, please edit your Subject line so it is more specific
than "Re: Contents of pgbr-geral digest..."
Tópicos de Hoje:
1. Re: Ter uma tabela com ordem sempre mantida (Tiago Adami)
2. Re: Ter uma tabela com ordem sempre mantida
(Euler Taveira de Oliveira)
3. Re: Ter uma tabela com ordem sempre mantida (Andre Fernandes)
----------------------------------------------------------------------
Message: 1
Date: Sat, 7 Nov 2009 00:36:04 -0200
From: Tiago Adami <adamitj@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<950f30a10911061836l572d3ce3u5b653a72201b7056@...>
Content-Type: text/plain; charset="utf-8"
Certo JotaComm, concordo com sua posição, mas durante a minha sugestão não
tinha informações para dar a melhor solução.
Mas continuando, a questão que me veio à cabeça inicialmente é de quantos
registros existem no universo deste problema, e em qual intervalo de tempo a
fila recebe ou perde registros que exijam uma nova reorganização.
Como não sabemos ainda se o desempenho é baixo na execução da função de
ordenação ou durante a atualização dos registros na tabela (Rodrigo por
favor nos diga) eu sugeri a criação do índice clusterizado. Porém, após
reler os posts do Rodrigo, me veio à cabeça uma solução que encontrei muito
tempo atrás para resolver um problema parecido, onde a cada nova linha
inserida era necessário reorganizar quase todos os registros de uma tabela
de "chamados", que possuíam um número único de prioridade na fila
determinando a ordem de atendimento.
Nesta ocasião eu utilizava uma pesquisa binária começando do fim ao início
da fila para encontrar em qual parte o registro seria encaixado. Após isto,
todos os registros do ponto de inserção até o início da fila eram
atualizados para receber o novo valor de prioridade (maior prioridade,
início da fila). Exemplo:
Prioridade, Registro
8, A
7, B
6, C
5, D
4, E
3, F
2, G
1, H
Inserindo registro BA com prioridade 7 (valor definido pelo aplicativo
segundo regras pré-estabelecidas): Neste caso pesquisaria: BA >= H, depois
BA >= D e por fim BA >= B, sendo este último a condição satisfatória da
pesquisa binária. Então ficaria:
Prioridade, Registro
8, A
7, B
7, BA -- O registro entrou aqui
6, C
5, D
4, E
3, F
2, G
1, H
Mas o campo "prioridade" não poderia ter valores repetidos, então era feito
um algoritmo de atualização para recalcular a prioridade de todos que no
final resultava:
Prioridade, Registro
9, A
8, BA -- por ser mais recente, passou à frente do registro "B" (regra de
negócio)
7, B
6, C
5, D
4, E
3, F
2, G
1, H
O problema disso tudo era que o número de registros na fila beirava os 1.000
(isso mesmo, hum mil), mas como a tabela possuía um grande número de colunas
indexadas e triggers disparadas a cada update, a atualização direta era
muito lenta. Bolei então uma solução bem simples para o problema, criando
uma tabela auxiliar chamada "chamado_prioridade" que mantinha apenas as
colunas "Prioridade" e "Registro" (que na verdade tinha outro nome e era a
chave primária da tabela de chamados).
A stored procedure era executada, e cada registro reorganizado era gravado
em uma tabela temporária, idêntica à "chamado_prioridade". Após reorganizar
todos os registros, o processo finalizava com:
DELETE FROM chamado_prioridade;
INSERT INTO chamado_prioridade( prioridade, registro ) SELECT prioridade,
registro FROM chamado_prioridade_tmp;
DROP TABLE chamado_prioridade_tmp;
E isso deu um ganho de tempo antes inimaginável no processo, pois em média a
cada 5 minutos um novo chamado entrava na fila.
Bem, por mais ridículo que esta minha "solução" possa ser, espero que alguma
idéia possa ser aproveitada. Não sei como esta solução se comportaria com
milhares ou milhões de registros...
P.S: Quando um chamado era atendido, ele era removido da fila (causando nova
reorganização). Ou seja, o tamanho da fila nunca seria de 0 para o infinito,
variava entre 1 e pouco mais de 1000.
--
TIAGO J. ADAMI
http://www.adamiworks.com
2009/11/5 JotaComm <jota.comm@...>
> Olá, Tiago
>
> O custo disso é que para cada inserção é necessário clusterizar novamente a
> tabela a partir do índice, pois a cada inserção é provável que o registro vá
> para o final da tabela.
>
> 2009/10/26 Tiago Adami <adamitj@...>
>
> Talvez clusterizar um índice nesta tabela ajude no desempenho, já que os
>> dados serão reorganizados a cada registro gravado [1]. Assim, a ordem
>> retornada será sempre a mesma de um ORDER BY sobre a mesma coluna.
>>
>> Na verdade não sei muito o que dizer, isso foi um *chute*. Fica um tanto
>> abstrato tentar dar alguma opinião sem um exemplo. Se puder exemplificar
>> alguma coisa seria mais fácil.
>>
>> [1] http://www.postgresql.org/docs/8.4/static/sql-cluster.html
>>
>> --
>> TIAGO J. ADAMI
>> http://www.adamiworks.com
>>
>> 2009/10/26 Rodrigo Sperb <rodrigosperb@...>
>>
>>> Olá a todos,
>>>
>>>
>>> Eu tenho uma função implementada em PL\PgSQL que itera sempre pegando a
>>> linha do topo após ordenar por uma certa coluna. Isso se repete em todas
>>> iterações, e como faço atualizações nessa tabela (é uma "priority queue",
>>> para quem é familiarizado com notação matemática...) no intermédio, não
>>> possa ter a ordenação pré-estabelecida e sempre pegar o topo simplesmente...
>>> Preciso reordenar sempre.
>>>
>>> Acontece que isso leva algum tempo e eu preciso melhorar a performance do
>>> meu algoritmo. Ele é parte da minha tese de mestrado aqui na Holanda. Meu
>>> orientador me comentou que poderíamos ter as posições pré-definidas e fazer
>>> atualizações "inteligentes", mantendo cada registro na devida posição que
>>> deve ocupar... Mas ele ainda não me disse nada de como fazer. Queria, então,
>>> saber se alguém tem alguma idéia de como se pode fazer algo assim?
>>>
>>> Desde já agradeço.
>>>
>>> Rodrigo Sperb
>>>
>>> _______________________________________________
>>> pgbr-geral mailing list
>>> pgbr-geral@...
>>> https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
>>>
>>>
>>
>>
>>
>>
>> _______________________________________________
>> pgbr-geral mailing list
>> pgbr-geral@...
>> https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
>>
>>
>
> []s
> --
> JotaComm
> http://jotacomm.wordpress.com
>
> _______________________________________________
> pgbr-geral mailing list
> pgbr-geral@...
> https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
>
>
-------------- Pr?a Parte ----------
Um anexo em HTML foi limpo...
URL: http://listas.postgresql.org.br/pipermail/pgbr-geral/attachments/20091107/1602d443/attachment.html
------------------------------
Message: 2
Date: Sat, 07 Nov 2009 00:36:09 -0200
From: Euler Taveira de Oliveira <euler@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID: <4AF4DD19.7010907@...>
Content-Type: text/plain; charset=UTF-8
Tiago Adami escreveu:
> Mas continuando, a questão que me veio à cabeça inicialmente é de
> quantos registros existem no universo deste problema, e em qual
> intervalo de tempo a fila recebe ou perde registros que exijam uma nova
> reorganização.
>
Por que não utilizar simplesmente o _fillfactor_? Manter uma tabela ordenada é
uma tarefa árdua (principalmente se essa tabela sofre muitas modificações).
--
Euler Taveira de Oliveira
http://www.timbira.com/
------------------------------
Message: 3
Date: Sat, 7 Nov 2009 07:27:43 -0200
From: Andre Fernandes <fernandes.andre@...>
Subject: Re: [pgbr-geral] Ter uma tabela com ordem sempre mantida
To: Comunidade PostgreSQL Brasileira
<pgbr-geral@...>
Message-ID:
<eb3e4370911070127pc75517fl410f07a0d55d3fee@...>
Content-Type: text/plain; charset="iso-8859-1"
Euler,
Desculpa a ignorância, mas o que é o _fillfactor_?
2009/11/7 Euler Taveira de Oliveira <euler@...>
> Tiago Adami escreveu:
> > Mas continuando, a questão que me veio à cabeça inicialmente é de
> > quantos registros existem no universo deste problema, e em qual
> > intervalo de tempo a fila recebe ou perde registros que exijam uma nova
> > reorganização.
> >
> Por que não utilizar simplesmente o _fillfactor_? Manter uma tabela
> ordenada é
> uma tarefa árdua (principalmente se essa tabela sofre muitas modificações).
>
>
> --
> Euler Taveira de Oliveira
> http://www.timbira.com/
> _______________________________________________
> pgbr-geral mailing list
> pgbr-geral@...
> https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
>
--
André de Camargo Fernandes
-------------- Próxima Parte ----------
Um anexo em HTML foi limpo...
URL: http://listas.postgresql.org.br/pipermail/pgbr-geral/attachments/20091107/c58868db/attachment-0001.htm
------------------------------
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
Fim da Digest pgbr-geral, volume 33, assunto 18
***********************************************
_______________________________________________
pgbr-geral mailing list
pgbr-geral@...
https://listas.postgresql.org.br/cgi-bin/mailman/listinfo/pgbr-geral
|
