Existe algo como uma diretiva que eu possa usar em um script para forçar o SSMS a ativar/desativar o modo SQLCMD?
Ao testar alguns scripts de migração com uma cópia dos dados de produção (os scripts funcionam bem com os dados de desenvolvimento), encontrei uma situação curiosa. A CONSTRAINT mudou, então estou emitindo comandos DROP + ADD:
ALTER TABLE A_DUP_CALLE
DROP CONSTRAINT A_DUP_CALLE_UK1;
ALTER TABLE A_DUP_CALLE
ADD CONSTRAINT A_DUP_CALLE_UK1 UNIQUE (
CONTROL_ID,
CALLE_AYTO_DUPL
)
ENABLE;
O comando DROP funcionou bem, mas o ADD falhou. Agora, estou em um círculo vicioso. Não consigo descartar a restrição porque ela não existe (o descarte inicial funcionou conforme o esperado):
ORA-02443: Não é possível descartar restrição - restrição inexistente
E não consigo criá-lo porque o nome já existe:
ORA-00955: nome já é usado por um objeto existente
Eu digito na caixa de pesquisaA_DUP_CALLE_UK1 do SQL Developer e... aí está! Owner, nome da tabela, tablescape... tudo combina: não é um objeto diferente com o mesmo nome, é minha restrição original. A tabela aparece nos detalhes da restrição, mas a restrição não aparece nos detalhes da tabela.
Minhas perguntas:
- Qual é a explicação para isso?
- Como posso garantir que isso não acontecerá quando eu fizer a atualização real no servidor ativo?
(O servidor é 10g XE, não tenho reputação suficiente para criar a tag.)
Recebi a tarefa de migrar um banco de dados PostgreSQL 8.2.x para outro servidor. Para fazer isso estou usando o pgAdmin 1.12.2 (no Ubuntu 11.04 a propósito) e usando o Backup and Restore usando o formato custom/compress (.backup) e codificação UTF8.
O banco de dados original está em UTF8, assim:
-- Database: favela
-- DROP DATABASE favela;
CREATE DATABASE favela
WITH OWNER = favela
ENCODING = 'UTF8'
TABLESPACE = favela
CONNECTION LIMIT = -1;
Estou criando esse banco de dados exatamente assim no servidor de destino. Mas quando restauro o banco de dados do arquivo .backup usando a opção Restaurar, ele me apresenta alguns destes erros:
pg_restore: restoring data for table "arena"
pg_restore: [archiver (db)] Error while PROCESSING TOC:
pg_restore: [archiver (db)] Error from TOC entry 2173; 0 35500 TABLE DATA arena favela
pg_restore: [archiver (db)] COPY failed: ERROR: invalid byte sequence for encoding "UTF8": 0xe3a709
HINT: This error can also happen if the byte sequence does not match the encoding expected by the server, which is controlled by "client_encoding".
CONTEXT: COPY arena, line 62
Quando eu verifico qual registro acionou este erro de fato alguns campos vartext possuem caracteres diacríticos como ç (usado em português, por exemplo, "caça"), e quando eu os removo manualmente do texto nos registros o erro passa para o próximo registro que os possui - pois quando o copy apresenta um erro ele para de inserir dados nesta tabela. E eu não quero substituí-los manualmente um por um para conseguir isso.
Mas é meio estranho porque com UTF8 não deveria haver esse tipo de problema, certo?
Eu não sei como eles chegaram lá em primeiro lugar. Estou apenas migrando o banco de dados e suponho que de alguma forma o banco de dados estava como em LATIN1 e depois foi alterado indevidamente para UTF8.
Existe alguma maneira de verificar se uma tabela/banco de dados possui sequências UTF8 inválidas? Ou alguma maneira de impor/reconverter esses caracteres no UFT8 para não ter problemas ao executar a restauração?
Desde já, obrigado.
Pesquisando por aí parece haver relatórios mistos se o tamanho de uma VARCHAR2coluna no Oracle afeta o desempenho ou não.
Gostaria de dar VARCHARuma pequena reviravolta na questão do tamanho e espero obter algumas informações sobre isso:
Dado (multilinha) campos de texto livre ( não coisas curtas como nomes) que você deseja armazenar em um banco de dados (Oracle), há algum ponto (desempenho de escrita ou outro) em não maximizar a VARCHARcapacidade ( VARCHAR2(4000)no Oracle), mas escolher um valor menor, como 1024 ou 512, porque provavelmente será suficiente em 98% dos casos.
Isenção de responsabilidade: por favor, tenha paciência comigo como alguém que usa bancos de dados apenas uma pequena fração de seu tempo de trabalho. (Na maioria das vezes eu faço programação C++ no meu trabalho, mas todo mês preciso pesquisar/consertar/adicionar algo em um banco de dados Oracle.)
Eu precisei repetidamente escrever consultas SQL complexas, tanto para consultas ad-hoc quanto para consultas incorporadas a aplicativos, onde grandes partes das consultas eram apenas "código" repetido.
Escrever tais abominações em uma linguagem de programação tradicional causaria sérios problemas, mas eu ( eu ) ainda não consegui encontrar nenhuma técnica decente para evitar a repetição do código de consulta SQL.
Editar: 1º, quero agradecer aos respondentes que forneceram excelentes melhorias ao meu exemplo original . No entanto, esta questão não é sobre o meu exemplo. É sobre repetitividade em consultas SQL. Como tal, as respostas ( JackP , Leigh ) até agora fazem um ótimo trabalho em mostrar que você pode reduzir a repetitividade escrevendo consultas melhores . No entanto, mesmo assim, você enfrenta alguma repetitividade que aparentemente não pode ser removida: isso sempre me incomodou com o SQL. Em linguagens de programação "tradicionais", posso refatorar bastante para minimizar a repetitividade no código, mas com o SQL parece que não há ferramentas (?) Que permitam isso, exceto para escrever uma instrução menos repetitiva para começar.
Observe que removi a tag Oracle novamente, pois ficaria genuinamente interessado se não houvesse banco de dados ou linguagem de script que permitisse algo mais.
Aqui está uma joia que montei hoje. Ele basicamente informa a diferença em um conjunto de colunas de uma única tabela. Por favor, dê uma olhada no código a seguir, esp. a consulta grande no final. Continuo abaixo.
--
-- Create Table to test queries
--
CREATE TABLE TEST_ATTRIBS (
id NUMBER PRIMARY KEY,
name VARCHAR2(300) UNIQUE,
attr1 VARCHAR2(2000),
attr2 VARCHAR2(2000),
attr3 INTEGER,
attr4 NUMBER,
attr5 VARCHAR2(2000)
);
--
-- insert some test data
--
insert into TEST_ATTRIBS values ( 1, 'Alfred', 'a', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 2, 'Batman', 'b', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 3, 'Chris', 'c', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values ( 4, 'Dorothee', 'd', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 5, 'Emilia', 'e', 'Barfoo', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 6, 'Francis', 'f', 'Barfoo', 99, 44, 'e');
insert into TEST_ATTRIBS values ( 7, 'Gustav', 'g', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 8, 'Homer', 'h', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 9, 'Ingrid', 'i', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (10, 'Jason', 'j', 'Bob', 33, 44, 'e');
insert into TEST_ATTRIBS values (12, 'Konrad', 'k', 'Bob', 66, 44, 'e');
insert into TEST_ATTRIBS values (13, 'Lucas', 'l', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (14, 'DUP_Alfred', 'a', 'FOOBAR', 33, 44, 'e');
insert into TEST_ATTRIBS values (15, 'DUP_Chris', 'c', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values (16, 'DUP_Dorothee', 'd', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (17, 'DUP_Gustav', 'X', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values (18, 'DUP_Homer', 'h', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values (19, 'DUP_Ingrid', 'Y', 'foo', 99, 44, 'e');
insert into TEST_ATTRIBS values (20, 'Martha', 'm', 'Bob', 33, 88, 'f');
-- Create comparison view
CREATE OR REPLACE VIEW TA_SELFCMP as
select
t1.id as id_1, t2.id as id_2, t1.name as name, t2.name as name_dup,
t1.attr1 as attr1_1, t1.attr2 as attr2_1, t1.attr3 as attr3_1, t1.attr4 as attr4_1, t1.attr5 as attr5_1,
t2.attr1 as attr1_2, t2.attr2 as attr2_2, t2.attr3 as attr3_2, t2.attr4 as attr4_2, t2.attr5 as attr5_2
from TEST_ATTRIBS t1, TEST_ATTRIBS t2
where t1.id <> t2.id
and t1.name <> t2.name
and t1.name = REPLACE(t2.name, 'DUP_', '')
;
-- NOTE THIS PIECE OF HORRIBLE CODE REPETITION --
-- Create comparison report
-- compare 1st attribute
select 'attr1' as Different,
id_1, id_2, name, name_dup,
CAST(attr1_1 AS VARCHAR2(2000)) as Val1, CAST(attr1_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr1_1 <> attr1_2
or (attr1_1 is null and attr1_2 is not null)
or (attr1_1 is not null and attr1_2 is null)
union
-- compare 2nd attribute
select 'attr2' as Different,
id_1, id_2, name, name_dup,
CAST(attr2_1 AS VARCHAR2(2000)) as Val1, CAST(attr2_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr2_1 <> attr2_2
or (attr2_1 is null and attr2_2 is not null)
or (attr2_1 is not null and attr2_2 is null)
union
-- compare 3rd attribute
select 'attr3' as Different,
id_1, id_2, name, name_dup,
CAST(attr3_1 AS VARCHAR2(2000)) as Val1, CAST(attr3_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr3_1 <> attr3_2
or (attr3_1 is null and attr3_2 is not null)
or (attr3_1 is not null and attr3_2 is null)
union
-- compare 4th attribute
select 'attr4' as Different,
id_1, id_2, name, name_dup,
CAST(attr4_1 AS VARCHAR2(2000)) as Val1, CAST(attr4_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr4_1 <> attr4_2
or (attr4_1 is null and attr4_2 is not null)
or (attr4_1 is not null and attr4_2 is null)
union
-- compare 5th attribute
select 'attr5' as Different,
id_1, id_2, name, name_dup,
CAST(attr5_1 AS VARCHAR2(2000)) as Val1, CAST(attr5_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr5_1 <> attr5_2
or (attr5_1 is null and attr5_2 is not null)
or (attr5_1 is not null and attr5_2 is null)
;
Como você pode ver, a consulta para gerar um "relatório de diferenças" usa o mesmo bloco SQL SELECT 5 vezes (pode facilmente ser 42 vezes!). Isso me parece absolutamente com morte cerebral (posso dizer isso, afinal eu escrevi o código), mas não consegui encontrar nenhuma boa solução para isso.
Se isso fosse uma consulta em algum código de aplicativo real, eu poderia escrever uma função que remenda essa consulta como uma string e, em seguida, executaria a consulta como uma string.
- -> Construir strings é horrível e horrível de testar e manter. Se o "código do aplicativo" for escrito em uma linguagem como PL/SQL, parece tão errado que dói.
Como alternativa, se usado em PL/SQL ou algo semelhante, acho que há alguns meios processuais para tornar essa consulta mais fácil de manter.
- -> Desdobrar algo que pode ser expresso em uma única consulta em etapas processuais apenas para evitar a repetição de código também parece errado.
Se essa consulta fosse necessária como uma exibição no banco de dados, então - pelo que entendi - não haveria outra maneira senão manter a definição de exibição conforme postei acima. (!!?)
- -> Na verdade, tive que fazer alguma manutenção em uma definição de visualização de 2 páginas, uma vez que não estava muito longe da declaração acima. Obviamente, alterar qualquer coisa nessa exibição exigia uma pesquisa de texto regexp na definição da exibição para saber se a mesma subinstrução foi usada em outra linha e se precisava ser alterada lá.
Então, como diz o título - que técnicas existem para evitar ter que escrever tais abominações?
Como faço para mostrar o binlog_formatem um servidor MySQL?
E se eu não gostar, como faço para defini-lo para XX permanentemente?
Onde XX é STATEMENT, ROWou MIXED.
Existe um comando SQL que posso executar para determinar o modelo de recuperação do meu banco de dados? Eu quero saber se sua recuperação total ou não.
Sou novo em bancos de dados Oracle e gostaria de desenvolver um dicionário de dados e diagramas ER para nossos bancos de dados existentes. Você tem dicas, scripts, ferramentas para fazer isso?
Eu me deparei com uma visão em nosso banco de dados hoje onde a primeira instrução na cláusula where era where 1 = 1. Isso não deveria retornar true para cada registro? Por que alguém escreveria isso se não está filtrando nenhum registro?
Eu gerencio um aplicativo que tem um back-end de banco de dados Oracle muito grande (quase 1 TB de dados com mais de 500 milhões de linhas em uma tabela). O banco de dados realmente não faz nada (sem SPocs, sem gatilhos ou qualquer coisa), é apenas um armazenamento de dados.
Todos os meses, somos obrigados a limpar os registros das duas tabelas principais. Os critérios para a eliminação variam e são uma combinação de idade da linha e alguns campos de status. Normalmente, acabamos limpando entre 10 e 50 milhões de linhas por mês (adicionamos cerca de 3 a 5 milhões de linhas por semana por meio de importações).
Atualmente, temos que fazer essa exclusão em lotes de cerca de 50.000 linhas (ou seja, excluir 50.000, confirmar, excluir 50.000, confirmar, repetir). A tentativa de excluir todo o lote de uma só vez faz com que o banco de dados não responda por cerca de uma hora (dependendo do número de linhas). Excluir as linhas em lotes como este é muito difícil para o sistema e normalmente temos que fazer isso "conforme o tempo permitir" ao longo de uma semana; permitir que o script seja executado continuamente pode resultar em uma degradação de desempenho que é inaceitável para o usuário.
Acredito que esse tipo de exclusão em lote também degrada o desempenho do índice e tem outros impactos que eventualmente causam a degradação do desempenho do banco de dados. Existem 34 índices em apenas uma tabela, e o tamanho dos dados do índice é realmente maior do que os próprios dados.
Aqui está o script que um de nossos funcionários de TI usa para fazer essa limpeza:
BEGIN
LOOP
delete FROM tbl_raw
where dist_event_date < to_date('[date]','mm/dd/yyyy') and rownum < 50000;
exit when SQL%rowcount < 49999;
commit;
END LOOP;
commit;
END;
Este banco de dados deve estar em 99,99999% e só temos uma janela de manutenção de 2 dias uma vez por ano.
Estou procurando um método melhor para remover esses registros, mas ainda não encontrei nenhum. Alguma sugestão?