FallenAngel's questions

Eu tenho que criar números de sequência com base no usuário relacionado. Curti:

╔════════════╦═════════════╦═══════════════════╗
║ Row Id     ║ User Id     ║ Sequence Number   ║
╠════════════╬═════════════╬═══════════════════╣
║ 1          ║ 1           ║         1         ║
║ 2          ║ 1           ║         2         ║
║ 3          ║ 2           ║         1         ║
║ 4          ║ 2           ║         2         ║
║ 5          ║ 3           ║         1         ║
║ 6          ║ 1           ║         3         ║
╚════════════╩═════════════╩═══════════════════╝

Tenho alguns pré-requisitos:

• Cada número de seqüência deve estar entre 1 e 9999. Após 9999, deve saltar para 1 e continuar a partir daí. (propriedade CICLO da Sequência)
• Os números de sequência devem ser gerados com base no ID do usuário. Cada UserId deve ter sua própria sequência.
• Os números de sequência devem ser sequenciais. tal que para o ID de usuário 5: Sequência # 123 deve ser seguida por 124, salto ou reutilização de um número não deve acontecer.

Então, usar uma sequência parece muito certo para mim. Mas não consegui adicionar distinção de ID de usuário à sequência.

CREATE SEQUENCE [dbo].[seq_SequenceNumber] 
AS [smallint]
START WITH 1
INCREMENT BY 1
MINVALUE 1
MAXVALUE 9999
CYCLE 
NO CACHE  

Como posso adicionar a partição UserId a essa sequência?

Estou rodando Postgresql 9.1no Ubuntu. A versão exata do Postgresql é 9.1+129ubuntu1como mostra meu gerenciador de pacotes.

Eu tenho 2 bancos de dados que estão ativamente em uso e são usados ​​de um servidor remoto.

Desejo registrar consultas que tenham um longo tempo de execução. Então eu defino os seguintes parâmetros no /etc/postgresql/9.1/main/postgresql.confarquivo

log_min_duration_statement = 10000
log_statement = 'mod'

portanto, o Postgresql registrará consultas que demoram mais de 10 segundos.

Mas quando faço reloada configuração do postgres, o Postgresql começa a registrar todas as consultas que se ajustam ao log_statementvalor. Que defino a duração para 100 segundos para ter certeza

log_min_duration_statement = 100000

Mas o Postgresql continua registrando todas as consultas que correspondem ao log_statementvalor, independentemente do log_min_duration_statementvalor.

Definir log_statementcomo noneparecia interromper o registro.

Há algo que eu perdi sobre a configuração?

Estou usando Postgresql 9.1 com extensão *pg_trgm*. Eu preciso criar um índice em um campo baseado em texto. Não preciso de pesquisas de texto completo, uso ILIKEconsultas para fazer minhas pesquisas.

Vou usar, pg_trgmmas não tenho muita experiência com índices gine . gistTerei muitas INSERTdeclarações (~15.000 diariamente) e muito poucas UPDATEdeclarações (pode ser 1 ou 2 em uma semana).

Qual será a sobrecarga de atualização de índice para um giníndice em tal tabela? Ou é gistmais adequado?

Preciso criar um database modelque inclua um campo para armazenar valores exclusivos de 20 dígitos. Que será usado por muitos clientes em uma API.

O valor deve ter 20 dígitos, ser numérico e exclusivo. A melhor abordagem parecia criar um big-intcampo de incremento automático, mas big-int suporta valores de até 9223372036854775807 (19 dígitos). Usar numeric(20,0)é inútil, pois embora o numérico suporte valores maiores, o Postgres 8.4 não me permite criar um sequencee gera erro

CREATE SEQUENCE my_sequence_name INCREMENT BY 1 NO MINVALUE NO MAXVALUE START WITH 10000000000000000101;

ERRO: o valor "10000000000000000101" está fora do intervalo para o tipo bigint

Para integridade dos dados, devo lidar com isso no POstgresql. Qual é a maneira eficiente de lidar com isso?

Estou usando Postgresql 8.4 e Django 1.3

ATUALIZAÇÃO: Acho melhor fazer um esclarecimento... Estou tentando achar uma forma de resolver isso dentro do SGBD. Portanto, qualquer solução que não seja de banco de dados será evitada, a menos que eu não tenha outra escolha. Descanso é o motivo da minha pergunta:

Estou fazendo uma API que se comunica com um Banco para operações 3D seguras. A API do banco exigia um identificador numérico exclusivo de 20 dígitos para a transação, então decidi criar um valor de ID que eu possa usar tanto para a API do banco quanto para minha API que usará essa tabela etc.

A declaração de 10000000000000000101é porque, a API do banco deseja que seja um valor válido de 20 dígitos integer, portanto, deve ser pelo menos 10000000000000000000.

Resolver isso dentro do DBMS é melhor para desempenho e integridade de dados. Uma ideia que pensei foi armazenar o valor como um auto-increment big-integerno campo do banco de dados e analisá-lo manualmente para string e fazer algumas configurações como:

bid = str(23434545) # value in the DB field
final_value = '1' + '0'* (19-len(bid)) + bid

que faz final_valueum inteiro de 20 dígitos que começa com 1 e termina com meu valor auto-incrementado. e o meio é preenchido com zeros.

Mas no caso de lidar com consultas SELECTe INSERT, manter a lógica fora do DBMS é baixo, tão ruim.