Ao executar as seguintes consultas no MS SQL Server 2012, a segunda consulta falha, mas não a primeira. Além disso, quando executadas sem as cláusulas where, ambas as consultas falharão. Não sei por que qualquer um deles falharia, já que ambos deveriam ter conjuntos de resultados vazios. Qualquer ajuda/insight é apreciada.
create table #temp
(id int primary key)
create table #temp2
(id int)
select 1/0
from #temp
where id = 1
select 1/0
from #temp2
where id = 1
Eu criei um portal de superusuário com o seguinte comando
create role portal with superuser password 'portal'
Quando tentei fazer login no postgres com o usuário do portal, estou recebendo o seguinte erro no Rails.
FATAL: role "portal" is not permitted to log in
Não consigo acompanhar o que está acontecendo.
é claro que posso alterar o usuário com o comando de login para permitir que o usuário do portal faça login. Gostaria de entender por que o superusuário não consegue fazer o login.
Para usar HAVINGem consultas SQL, deve haver um GROUP BYpara agregar os nomes das colunas?
Existem casos especiais em que é possível usar HAVINGsem GROUP BYconsultas SQL?
Eles devem coexistir ao mesmo tempo?
Tenho alguns bancos de dados criados usando Entity Framework Code First; os aplicativos estão funcionando e, em geral, estou muito feliz com o que o Code First me permite fazer. Eu sou um programador primeiro, e um DBA segundo, por necessidade. Estou lendo sobre DataAttributes para descrever melhor em C# o que quero que o banco de dados faça; e minha pergunta é: que penalidade estarei comendo por ter essas nvarchar(max)strings na minha tabela (veja o exemplo abaixo)?
Existem várias colunas nesta tabela em particular; em C# eles são definidos como tal:
[Key]
[DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
public int ID { get; set; }
public string Name { get; set; }
public string Message { get; set; }
public string Source { get; set; }
public DateTime Generated { get; set; }
public DateTime Written { get; set; }
Espero consultar e/ou classificar com base em Nome, Origem, Gerado e Escrito. Espero que Name e Source estejam no comprimento de 0-50 caracteres, ocasionalmente até 150. Espero que esta tabela comece bem pequena (<100k linhas), mas cresça significativamente ao longo do tempo (>1m linhas). Obviamente, a mensagem pode ser pequena ou grande e provavelmente não será consultada.
O que eu quero saber, há um impacto de desempenho para minhas colunas Name e Source sendo definidas como nvarchar(max)quando eu nunca espero que elas tenham mais de 150 caracteres?
Uma necessidade comum ao usar um banco de dados é acessar os registros em ordem. Por exemplo, se eu tiver um blog, quero poder reordenar minhas postagens em ordem arbitrária. Essas entradas geralmente têm muitos relacionamentos, portanto, um banco de dados relacional parece fazer sentido.
A solução comum que vi é adicionar uma coluna inteira order:
CREATE TABLE AS your_table (id, title, sort_order)
AS VALUES
(0, 'Lorem ipsum', 3),
(1, 'Dolor sit', 2),
(2, 'Amet, consect', 0),
(3, 'Elit fusce', 1);
Em seguida, podemos classificar as linhas orderpara colocá-las na ordem correta.
No entanto, isso parece desajeitado:
É fácil imaginar situações como:
orderorderentre os registrosIsso pode acontecer facilmente por vários motivos.
Esta é a abordagem adotada por aplicativos como o Joomla:
Você poderia argumentar que a interface aqui é ruim e que, em vez de humanos editarem números diretamente, eles deveriam usar setas ou arrastar e soltar - e provavelmente você estaria certo. Mas nos bastidores, a mesma coisa está acontecendo.
Algumas pessoas propuseram o uso de um decimal para armazenar a ordem, para que você possa usar "2,5" para inserir um registro entre os registros nas ordens 2 e 3. E embora isso ajude um pouco, é sem dúvida ainda mais confuso porque você pode acabar com decimais estranhos (onde você para? 2,75? 2,875? 2,8125?)
Existe uma maneira melhor de armazenar pedidos em uma tabela?
Eu tenho uma tabela que é usada por um aplicativo legado como substituto de IDENTITYcampos em várias outras tabelas.
Cada linha na tabela armazena o último ID usado LastIDpara o campo nomeado em IDName.
Ocasionalmente, o proc armazenado obtém um impasse - acredito que construí um manipulador de erros apropriado; no entanto, estou interessado em ver se esta metodologia funciona como eu acho que funciona, ou se estou latindo para a árvore errada aqui.
Estou bastante certo de que deve haver uma maneira de acessar esta tabela sem nenhum impasse.
O próprio banco de dados é configurado com READ_COMMITTED_SNAPSHOT = 1.
Primeiro, aqui está a tabela:
CREATE TABLE [dbo].[tblIDs](
[IDListID] [int] NOT NULL
CONSTRAINT PK_tblIDs
PRIMARY KEY CLUSTERED
IDENTITY(1,1) ,
[IDName] [nvarchar](255) NULL,
[LastID] [int] NULL,
);
E o índice não clusterizado no IDNamecampo:
CREATE NONCLUSTERED INDEX [IX_tblIDs_IDName]
ON [dbo].[tblIDs]
(
[IDName] ASC
)
WITH (
PAD_INDEX = OFF
, STATISTICS_NORECOMPUTE = OFF
, SORT_IN_TEMPDB = OFF
, DROP_EXISTING = OFF
, ONLINE = OFF
, ALLOW_ROW_LOCKS = ON
, ALLOW_PAGE_LOCKS = ON
, FILLFACTOR = 80
);
GO
Alguns dados de exemplo:
INSERT INTO tblIDs (IDName, LastID)
VALUES ('SomeTestID', 1);
INSERT INTO tblIDs (IDName, LastID)
VALUES ('SomeOtherTestID', 1);
GO
O procedimento armazenado usado para atualizar os valores armazenados na tabela e retornar o próximo ID:
CREATE PROCEDURE [dbo].[GetNextID](
@IDName nvarchar(255)
)
AS
BEGIN
/*
Description: Increments and returns the LastID value from tblIDs
for a given IDName
Author: Hannah Vernon
Date: 2012-07-19
*/
DECLARE @Retry int;
DECLARE @EN int, @ES int, @ET int;
SET @Retry = 5;
DECLARE @NewID int;
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SET NOCOUNT ON;
WHILE @Retry > 0
BEGIN
BEGIN TRY
BEGIN TRANSACTION;
SET @NewID = COALESCE((SELECT LastID
FROM tblIDs
WHERE IDName = @IDName),0)+1;
IF (SELECT COUNT(IDName)
FROM tblIDs
WHERE IDName = @IDName) = 0
INSERT INTO tblIDs (IDName, LastID)
VALUES (@IDName, @NewID)
ELSE
UPDATE tblIDs
SET LastID = @NewID
WHERE IDName = @IDName;
COMMIT TRANSACTION;
SET @Retry = -2; /* no need to retry since the operation completed */
END TRY
BEGIN CATCH
IF (ERROR_NUMBER() = 1205) /* DEADLOCK */
SET @Retry = @Retry - 1;
ELSE
BEGIN
SET @Retry = -1;
SET @EN = ERROR_NUMBER();
SET @ES = ERROR_SEVERITY();
SET @ET = ERROR_STATE()
RAISERROR (@EN,@ES,@ET);
END
ROLLBACK TRANSACTION;
END CATCH
END
IF @Retry = 0 /* must have deadlock'd 5 times. */
BEGIN
SET @EN = 1205;
SET @ES = 13;
SET @ET = 1
RAISERROR (@EN,@ES,@ET);
END
ELSE
SELECT @NewID AS NewID;
END
GO
Exemplos de execuções do proc armazenado:
EXEC GetNextID 'SomeTestID';
NewID
2
EXEC GetNextID 'SomeTestID';
NewID
3
EXEC GetNextID 'SomeOtherTestID';
NewID
2
EDITAR:
Adicionei um novo índice, pois o índice existente IX_tblIDs_Name não está sendo usado pelo SP; Suponho que o processador de consulta esteja usando o índice clusterizado, pois precisa do valor armazenado em LastID. De qualquer forma, este índice é usado pelo plano de execução real:
CREATE NONCLUSTERED INDEX IX_tblIDs_IDName_LastID
ON dbo.tblIDs
(
IDName ASC
)
INCLUDE
(
LastID
)
WITH (FILLFACTOR = 100
, ONLINE=ON
, ALLOW_ROW_LOCKS = ON
, ALLOW_PAGE_LOCKS = ON);
EDIÇÃO #2:
Eu segui o conselho que @AaronBertrand deu e modifiquei um pouco. A ideia geral aqui é refinar a declaração para eliminar bloqueios desnecessários e, em geral, tornar o SP mais eficiente.
O código abaixo substitui o código acima de BEGIN TRANSACTIONto END TRANSACTION:
BEGIN TRANSACTION;
SET @NewID = COALESCE((SELECT LastID
FROM dbo.tblIDs
WHERE IDName = @IDName), 0) + 1;
IF @NewID = 1
INSERT INTO tblIDs (IDName, LastID)
VALUES (@IDName, @NewID);
ELSE
UPDATE dbo.tblIDs
SET LastID = @NewID
WHERE IDName = @IDName;
COMMIT TRANSACTION;
Como nosso código nunca adiciona um registro a esta tabela com 0 LastID, podemos supor que, se @NewID for 1, a intenção é anexar um novo ID à lista, caso contrário, estamos atualizando uma linha existente na lista.
Posso listar todas as tabelas em todos os esquemas usando
> \dt *.*
mas isso também lista as tabelas do sistema que superam em muito as minhas tabelas com as quais me importo. Eu gostaria de todas as tabelas (e possivelmente exibições) criadas por mim no esquema público e todos os esquemas que eu defini.
Espero encontrar uma maneira de fazer isso sem precisar adicionar esquemas explicitamente ao caminho de pesquisa à medida que os crio conforme descrito aqui:
https://stackoverflow.com/a/12902069
EDITAR:
Com base na resposta aceita, criei a seguinte exibição:
create view my_tables as
select table_catalog, table_schema, table_name, table_type
from information_schema.tables
where table_schema not in ('pg_catalog', 'information_schema');
E agora o seguinte comando me dá o que eu queria:
select * from my_tables;
Sou um DBA Oracle que também possui experiência em Sybase.
Quais são as principais diferenças arquitetônicas e conceituais entre as duas plataformas RDBMS?
Uma resposta semelhante à pergunta SQL Server->Oracle aqui seria mais útil.
Por que a consulta a seguir retorna linhas infinitas? Eu esperava que a EXCEPTcláusula encerrasse a recursão.
with cte as (
select *
from (
values(1),(2),(3),(4),(5)
) v (a)
)
,r as (
select a
from cte
where a in (1,2,3)
union all
select a
from (
select a
from cte
except
select a
from r
) x
)
select a
from r
Me deparei com isso enquanto tentava responder a uma pergunta no Stack Overflow.
SQL> desc dual
Name Null? Type
----------------------------------------- -------- ----------------------------
DUMMY VARCHAR2(1)
SQL> select 4*5 from dual;
4*5
----------
20
SQL>
Eu acho realmente estranho. Se não houver uma coluna chamada 4*5 em dual, como funciona a instrução select?
Além disso, por que não vejo o mesmo comportamento quando crio minha própria tabela dupla?
SQL> create table dual2(dummy varchar2(1));
Table created.
SQL> desc dual2
Name Null? Type
----------------------------------------- -------- ----------------------------
DUMMY VARCHAR2(1)
SQL> select 4*5 from dual2;
no rows selected
SQL>