All perguntas(dba)

Tenho colunas de preços sensíveis que gostaria de atualizar apenas por meio de um procedimento armazenado. Eu gostaria que todos os códigos ou tentativas manuais de alterar valores nessas colunas de preço falhem se não estiver usando os procedimentos armazenados projetados para atualizá-lo.

Estou pensando em implementar isso usando gatilhos e uma tabela de token. A ideia que estou considerando é ter uma tabela de tokens. os procedimentos armazenados terão que primeiro inserir valores na tabela de tokens. Em seguida, atualize as colunas de preço. O gatilho de atualização verificará se o token existe na tabela de tokens para a linha atualizada. Se encontrado, continuaria. se o token não for encontrado, ele lançará uma exceção e fará com que a transação de atualização falhe.

Existe uma maneira boa/melhor de implementar essa restrição?

Como o título diz. Eu até tentei, SELECT CONVERT(NUMERIC, 1/2)que também retornou 0.

Estou usando o SQLServer 2008.

Estou seguindo esta solução aqui https://stackoverflow.com/questions/3927690/howto-clean-a-mysql-innodb-storage-engine/4056261#comment14041132_4056261 e tentei aumentar meu innodb_buffer_pool_sizepara 4G e depois 1G (também 1024M) em além do tamanho do arquivo de log, mas o mysql não iniciará com esses valores. Se eu colocá-lo de volta para 512M, o mysql começa bem.

Como posso resolver isso? Meu servidor é de 16 GB e, de acordo com o Webmin sysinfo:

Real memory 15.62 GB total, 3.13 GB used

Enquanto isso, encontrei o log de erros também:

120529 10:29:32 mysqld_safe mysqld do arquivo pid /var/run/mysqld/mysqld.pid terminou

120529 10:29:33 mysqld_safe Iniciando o daemon mysqld com bancos de dados de /var/lib/mysql

120529 10:29:33 [Nota] Plugin 'FEDERATED' está desabilitado.

120529 10:29:33 InnoDB: O heap de memória do InnoDB está desabilitado

120529 10:29:33 InnoDB: Mutexes e rw_locks usam builtins atômicos GCC

120529 10:29:33 InnoDB: Tabelas compactadas usam zlib 1.2.3

120529 10:29:33 InnoDB: Usando AIO nativo do Linux

120529 10:29:33 InnoDB: Inicializando o pool de buffers, tamanho = 1,0 G

120529 10:29:33 InnoDB: Inicialização completa do buffer pool

InnoDB: Erro: arquivo de log ./ib_logfile0 é de tamanho diferente 0 134217728 bytes

InnoDB: do que especificado no arquivo .cnf 0 268435456 bytes!

Tenho certeza de que muitos aplicativos, aplicativos críticos, bancos e assim por diante fazem isso diariamente.

A ideia por trás de tudo isso é:

• todas as linhas devem ter um histórico
• todos os links devem permanecer coerentes
• deve ser fácil fazer solicitações para obter colunas "atuais"
• os clientes que compraram coisas obsoletas ainda devem ver o que compraram, mesmo que este produto não faça mais parte do catálogo

e assim por diante.

Aqui está o que eu quero fazer e explicarei os problemas que estou enfrentando.

Todas as minhas tabelas terão essas colunas:

• id
• id_origin
• date of creation
• start date of validity
• start end of validity

E aqui estão as ideias para operações CRUD:

• create = inserir nova linha com id_origin= id, date of creation=now, start date of validity=now, end date of validity=null (= significa que é o registro ativo atual)
• atualizar =
  • read = ler todos os registros com end date of validity==null
  • atualize o registro "atual" end date of validity=nulo com end date of validity=agora
  • crie um novo com os novos valores e end date of validity=null (= significa que é o registro ativo atual)
• delete = atualize o registro "atual" end date of validity=null com end date of validity=agora

Então aqui está o meu problema: com associações muitos-para-muitos. Vamos dar um exemplo com valores:

• Tabela A (id = 1, id_origin = 1, início=agora, fim=nulo)
• Tabela A_B (início=agora, fim=nulo, id_A = 1, id_B = 48)
• Tabela B (id = 48, id_origin = 48, início=agora, fim=nulo)

Agora eu quero atualizar a tabela A, registro id=1

• Eu marco id de registro=1 com end=agora

• Eu insiro um novo valor na tabela A e... caramba, perdi minha relação A_B , a menos que eu duplique a relação também... isso terminaria em uma tabela:

• Tabela A (id = 1, id_origin = 1, início=agora, fim=agora+8mn)

• Tabela A (id = 2, id_origin = 1, start=now+8mn, end=null)
• Tabela A_B (início=agora, fim=nulo, id_A = 1, id_B = 48)
• Tabela A_B (início=agora, fim=nulo, id_A = 2, id_B = 48)
• Tabela B (id = 48, id_origin = 48, início=agora, fim=nulo)

E... bem, eu tenho outro problema: a relação A_B: devo marcar (id_A = 1, id_B = 48) como obsoleto ou não (A - id=1 é obsoleto, mas não B - 48)?

Como lidar com isso?

Tenho que projetar isso em grande escala: produtos, parceiros e assim por diante.

Qual é a sua experiência sobre isso? Como você faria (como você fez)?

-- Editar

Eu encontrei este artigo muito interessante , mas não lida adequadamente com "obsolescência em cascata" (= o que estou perguntando na verdade)

O que NVLsignifica? Estou falando sobre a função Oracle e Informix (talvez algumas outras também) usadas para filtrar valores não NULL dos resultados da consulta (semelhante a COALESCEoutros bancos de dados).

Temos um aplicativo em que apenas uma tabela crescerá em milhões de linhas, mas o restante ficará um pouco abaixo de um milhão. Então, qual é o conselho que devemos usar innodb_file_per_table ou deixar apenas um .ibd? Eu li alguns artigos dizendo para não ir com isso, pois você precisa de mais acesso ao disco quando houver junções a serem executadas? Teremos junção entre esta tabela e outras para fins de geração de relatórios.

Quais são as principais diferenças entre Unique Keye Primary Keyno MySQL?

Estou criando um banco de dados no qual haverá cerca de 30 tabelas, com cada tabela contendo dezenas de milhões de linhas e cada tabela contendo uma única coluna importante e uma coluna de chave primária/estrangeira para maximizar a eficiência da consulta em face de pesadas atualizações e inserções e fazem uso intenso de índices clusterizados. Duas das tabelas conterão dados textuais de comprimento variável, com uma delas contendo centenas de milhões de linhas, mas o restante conterá apenas dados numéricos.

Como eu realmente quero espremer até a última gota de desempenho do hardware que tenho disponível (cerca de 64 GB de RAM, um SSD muito rápido e 16 núcleos), pensei em permitir que cada mesa tenha seu próprio arquivo para que, não importa se Estou juntando em 2, 3, 4, 5 ou mais tabelas, cada tabela sempre será lida usando um thread separado e a estrutura de cada arquivo será alinhada com o conteúdo da tabela, o que, com sorte, minimizaria a fragmentação e a tornaria mais rápida para o SQL Server adicionar ao conteúdo de qualquer tabela.

Uma ressalva, estou preso no SQL Server 2008 R2 Web Edition . O que significa que não posso usar o particionamento horizontal automático, o que descarta isso como uma melhoria de desempenho.

O uso de um arquivo por tabela realmente maximizará o desempenho ou estou ignorando as características internas do mecanismo do SQL Server que tornariam isso redundante?

Em segundo lugar, se usar um arquivo por tabela é vantajoso, por que create tablesó me dá a opção de alocar a tabela para um grupo de arquivos e não para um arquivo lógico específico? Isso exigiria que eu criasse um grupo de arquivos separado para cada arquivo em meu cenário, o que me sugere que talvez o SQL Server não esteja prevendo as vantagens que presumo viriam de fazer o que estou propondo.

Eu tenho um banco de dados MySQL na máquina A e quero acessar o mysqldump da máquina B.

Ambas as máquinas estão rodando no Linux e também tenho as credenciais de ambas, mas não consigo acessar o mysqldump. O que posso tentar?

Isso faria sentido para que o aplicativo reforçasse a integridade do banco de dados em vez de ter chaves estrangeiras, verificar restrições etc.?

Quanta melhoria de desempenho se pode esperar por não impor a integridade do banco de dados por meio de ferramentas internas de banco de dados?