Importei um banco de dados para o SSDT contendo uma referência a uma exibição do sistema (especificamente, sys.columns). O problema é que recebo avisos sobre referências não resolvidas quando construo o projeto
Pelo que vi nos fóruns do MSDN, parece que pode ser um problema conhecido: http://social.msdn.microsoft.com/Forums/en-US/ssdsgetstarted/thread/5a7026bd-0602-42e6-a639- d73bed903c26
Agora, sei que posso desligar o aviso ou ignorá-lo, mas alguém conhece uma solução real?
Obrigado
Estou tentando executar o sqlcmd.exe para configurar um novo banco de dados a partir da linha de comando. Estou usando o SQL SERVER Express 2012 no Windows 7 64 bits.
Aqui está o comando que eu uso:
SQLCMD -S .\MSSQLSERVER08 -V 17 -E -i %~dp0\aqualogyDB.sql -o %~dp0\databaseCreationLog.log
E aqui está um pedaço do script de criação de arquivo sql:
CREATE DATABASE aqualogy
COLLATE Modern_Spanish_CI_AS
WITH TRUSTWORTHY ON, DB_CHAINING ON;
GO
use aqualogy
GO
CREATE TABLE [dbo].[BaseLayers] (
[Code] nchar(100) NOT NULL ,
[Geometry] nvarchar(MAX) NOT NULL ,
[IsActive] bit NOT NULL DEFAULT ((1))
)
EXEC sp_updateextendedproperty @name = N'MS_Description', @value = N'Capas de cartografía base de la aplicaicón. Consideramos en Galia Móvil la cartografía(...)'
, @level0type = 'SCHEMA', @level0name = N'dbo'
, @level1type = 'TABLE', @level1name = N'BaseLayers'
Bem, por favor, verifique se há alguns acentos nas palavras; que é a descrição da tabela. O banco de dados é criado sem problemas. 'Collate' é entendido pelo script, como você pode ver na captura de tela anexada. Apesar disso, os acentos não são mostrados adequadamente ao examinar a tabela.
Eu realmente aprecio qualquer ajuda. Muito obrigado.
[Editar]: Olá a todos. Alterar a codificação do arquivo SQL usando o Notepad++ funcionou bem! Muito obrigado pela ajuda: aprendi algo interessante com este problema!
Eu quero listar todas as partições criadas por triggers dinâmicos no PostgreSQL 9.1.
Consegui gerar uma contagem de partições usando esta resposta relacionada de Frank Heikens .
Eu tenho uma tabela foocom um gatilho de inserção que cria foo_1, foo_2etc. dinamicamente. A partição para inserção é escolhida com base no id da chave primária, um particionamento baseado em intervalo.
É possível exibir todas as partições atualmente em vigor para a tabela foo?
Nota: não estou perguntando sobre o controle de versão completo.
Existe alguma maneira automática de manter um histórico de procedimentos armazenados no SQL Server.
Semelhante à forma como o Google Docs mantém automaticamente um histórico de versões de documentos e a Wikipedia mantém automaticamente um histórico de versões de artigos.
Não quero que os usuários atualizando procedimentos armazenados também tenham que manter um repositório de procedimentos armazenados. Isso é muito trabalho e as pessoas não vão fazer isso.
Espero que isso seja algo que eu possa ativar no SQL Server ...
(E por procedimentos armazenados realmente quero dizer funções, gatilhos, etc. Basicamente tudo em Programabilidade.)
Postei em https://stackoverflow.com/questions/14522224/how-to-keep-history-of-sql-server-stored-procedure-revisions primeiro porque suspeito que obteria mais visualizações lá.
Eu tenho uma instância do SQL Server que possui um servidor vinculado a um servidor Oracle. Há uma tabela no servidor Oracle chamada PersonOptionsque contém os seguintes dados:
╔══════════╦══════════╗
║ PersonID ║ OptionID ║
╠══════════╬══════════╣
║ 1 ║ A ║
║ 1 ║ B ║
║ 2 ║ C ║
║ 3 ║ B ║
║ 4 ║ A ║
║ 4 ║ C ║
╚══════════╩══════════╝
Eu preciso dinamizar esses dados para que os resultados sejam:
╔══════════╦═════════╦══════════╦══════════╗
║ PersonID ║ OptionA ║ Option B ║ Option C ║
╠══════════╬═════════╬══════════╬══════════╣
║ 1 ║ 1 ║ 1 ║ ║
║ 2 ║ ║ ║ 1 ║
║ 3 ║ ║ 1 ║ ║
║ 4 ║ 1 ║ ║ 1 ║
╚══════════╩═════════╩══════════╩══════════╝
Alguma sugestão?
Eu sou um novo no postgreSQL. Eu tenho 3 tabelas, uma tabela referencia as chaves primárias das outras 2 tabelas. Mas não consegui inserir dados no arquivo Table3. Veja o código abaixo:
DROP TABLE Table1 CASCADE;
CREATE TABLE Table1(
"DataID" bigint NOT NULL DEFAULT '0',
"AdData" integer DEFAULT NULL,
PRIMARY KEY ("DataID")
);
DROP TABLE IF EXISTS Table2 CASCADE;
CREATE TABLE Table2 (
"Address" numeric(20) NOT NULL DEFAULT '0',
"Value" numeric(20) DEFAULT NULL,
PRIMARY KEY ("Address")
);
DROP TABLE IF EXISTS Table3 CASCADE;
CREATE TABLE table3 (
"ID" bigint NOT NULL DEFAULT '0',
"DataID" bigint DEFAULT NULL,
"Address" numeric(20) DEFAULT NULL,
"Data" bigint DEFAULT NULL,
PRIMARY KEY ("ID"),
FOREIGN KEY ("DataID") REFERENCES Table1("DataID") on delete cascade on update cascade,
FOREIGN KEY ("Address") REFERENCES Table2("Address") on delete cascade on update cascade
);
ERRO: inserir ou atualizar na tabela "Table3" viola a restrição de chave estrangeira "Table3_DataID_fkey" DETALHE: A chave (DataID)=(27856) não está presente na tabela "Table1".
Quando tentei inserir dados nas 3 tabelas, ocorreu um erro. Consultei a documentação do postgreSQL e alterei meu código da seguinte forma: (Infelizmente apresentou outro erro)
DROP TABLE Table1 CASCADE;
CREATE TABLE Table1(
"DataID" bigint NOT NULL DEFAULT '0',
"AdData" integer DEFAULT NULL,
PRIMARY KEY ("DataID")
);
DROP TABLE IF EXISTS Table2 CASCADE;
CREATE TABLE Table2 (
"Address" numeric(20) NOT NULL DEFAULT '0',
"Value" numeric(20) DEFAULT NULL,
PRIMARY KEY ("Address")
);
DROP TABLE IF EXISTS Table3 CASCADE;
CREATE TABLE table3 (
"ID" bigint NOT NULL DEFAULT '0',
"DataID" bigint DEFAULT NULL REFERENCES Table1 ON DELETE RESTRICT,
"Address" numeric(20) DEFAULT NULL REFERENCES Table2 ON DELETE CASCADE,
"Data" bigint DEFAULT NULL,
PRIMARY KEY ("ID"),
PRIMARY KEY("DataID", "Address")
);
ERRO: várias chaves primárias para a tabela "Table3" não são permitidas LINE 65: PRIMARY KEY("DataID", "Address")
Por favor me ajude... Como posso criar a referência?
Mudei o IDas UNIQUEe removi a linha PRIMARY KEY ("ID"). Naquela época, ele mostra outro erro como:
ERRO: o valor de chave duplicado viola a restrição exclusiva "Table3_pkey"
Como você testa as credenciais do MySQL na linha de comando em um servidor Linux?
Gostaria de poder gerar byteacampos aleatórios de comprimento arbitrário (<1 Gb) para preencher dados de teste.
Qual a melhor maneira para fazer isto?
Desculpas antecipadamente pela pergunta muito detalhada. Incluí consultas para gerar um conjunto de dados completo para reproduzir o problema e estou executando o SQL Server 2012 em uma máquina de 32 núcleos. No entanto, não acho que isso seja específico do SQL Server 2012 e forcei um MAXDOP de 10 para este exemplo específico.
Eu tenho duas tabelas que são particionadas usando o mesmo esquema de partição. Ao juntá-los na coluna usada para particionamento, notei que o SQL Server não é capaz de otimizar uma junção de mesclagem paralela tanto quanto se poderia esperar e, portanto, optou por usar um HASH JOIN. Nesse caso específico, posso simular manualmente um MERGE JOIN paralelo muito mais ideal, dividindo a consulta em 10 intervalos separados com base na função de partição e executando cada uma dessas consultas simultaneamente no SSMS. Usando WAITFOR para executá-los precisamente ao mesmo tempo, o resultado é que todas as consultas são concluídas em aproximadamente 40% do tempo total usado pelo HASH JOIN paralelo original.
Existe alguma maneira de fazer com que o SQL Server faça essa otimização por conta própria no caso de tabelas particionadas de forma equivalente? Eu entendo que o SQL Server geralmente pode incorrer em muita sobrecarga para fazer um MERGE JOIN paralelo, mas parece que há um método de fragmentação muito natural com sobrecarga mínima neste caso. Talvez seja apenas um caso especializado que o otimizador ainda não é inteligente o suficiente para reconhecer?
Aqui está o SQL para configurar um conjunto de dados simplificado para reproduzir este problema:
/* Create the first test data table */
CREATE TABLE test_transaction_properties
( transactionID INT NOT NULL IDENTITY(1,1)
, prop1 INT NULL
, prop2 FLOAT NULL
)
/* Populate table with pseudo-random data (the specific data doesn't matter too much for this example) */
;WITH E1(N) AS (
SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1
UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1
)
, E2(N) AS (SELECT 1 FROM E1 a CROSS JOIN E1 b)
, E4(N) AS (SELECT 1 FROM E2 a CROSS JOIN E2 b)
, E8(N) AS (SELECT 1 FROM E4 a CROSS JOIN E4 b)
INSERT INTO test_transaction_properties WITH (TABLOCK) (prop1, prop2)
SELECT TOP 10000000 (ABS(CAST(CAST(NEWID() AS VARBINARY) AS INT)) % 5) + 1 AS prop1
, ABS(CAST(CAST(NEWID() AS VARBINARY) AS INT)) * rand() AS prop2
FROM E8
/* Create the second test data table */
CREATE TABLE test_transaction_item_detail
( transactionID INT NOT NULL
, productID INT NOT NULL
, sales FLOAT NULL
, units INT NULL
)
/* Populate the second table such that each transaction has one or more items
(again, the specific data doesn't matter too much for this example) */
INSERT INTO test_transaction_item_detail WITH (TABLOCK) (transactionID, productID, sales, units)
SELECT t.transactionID, p.productID, 100 AS sales, 1 AS units
FROM test_transaction_properties t
JOIN (
SELECT 1 as productRank, 1 as productId
UNION ALL SELECT 2 as productRank, 12 as productId
UNION ALL SELECT 3 as productRank, 123 as productId
UNION ALL SELECT 4 as productRank, 1234 as productId
UNION ALL SELECT 5 as productRank, 12345 as productId
) p
ON p.productRank <= t.prop1
/* Divides the transactions evenly into 10 partitions */
CREATE PARTITION FUNCTION [pf_test_transactionId] (INT)
AS RANGE RIGHT
FOR VALUES
(1,1000001,2000001,3000001,4000001,5000001,6000001,7000001,8000001,9000001)
CREATE PARTITION SCHEME [ps_test_transactionId]
AS PARTITION [pf_test_transactionId]
ALL TO ( [PRIMARY] )
/* Apply the same partition scheme to both test data tables */
ALTER TABLE test_transaction_properties
ADD CONSTRAINT PK_test_transaction_properties
PRIMARY KEY (transactionID)
ON ps_test_transactionId (transactionID)
ALTER TABLE test_transaction_item_detail
ADD CONSTRAINT PK_test_transaction_item_detail
PRIMARY KEY (transactionID, productID)
ON ps_test_transactionId (transactionID)
Agora estamos finalmente prontos para reproduzir a consulta abaixo do ideal!
/* This query produces a HASH JOIN using 20 threads without the MAXDOP hint,
and the same behavior holds in that case.
For simplicity here, I have limited it to 10 threads. */
SELECT COUNT(*)
FROM test_transaction_item_detail i
JOIN test_transaction_properties t
ON t.transactionID = i.transactionID
OPTION (MAXDOP 10)
No entanto, usar um único thread para processar cada partição (exemplo para a primeira partição abaixo) levaria a um plano muito mais eficiente. Eu testei isso executando uma consulta como a abaixo para cada uma das 10 partições precisamente no mesmo momento, e todas as 10 terminaram em pouco mais de 1 segundo:
SELECT COUNT(*)
FROM test_transaction_item_detail i
INNER MERGE JOIN test_transaction_properties t
ON t.transactionID = i.transactionID
WHERE t.transactionID BETWEEN 1 AND 1000000
OPTION (MAXDOP 1)
Preciso fazer uma SELECTconsulta onde recebo o valor do campo "dinheiro". O campo não existe realmente no banco de dados. Só preciso que a consulta retorne este campo com um valor fixo; neste caso um valor em USD.
Como faço para retornar um valor constante em uma SELECTinstrução?