eckes's questions

Há um problema de longa data(?) com o Oracle que, se você quiser usar um DISTINCT, selecione em uma coluna que possui um índice B*-Tree, mas é anulável, que o índice não é usado. (Como outras respostas sugerem, isso é verdade mesmo se houver uma restrição de verificação adicionada após o fato (sem nulos presentes)).

Existem várias maneiras de contornar isso (incluindo usar um índice BITMAP ou adicionar uma segunda coluna NON NULL ou constante ao índice). Porém acabei de notar que se eu fizer o SELECT DISTINCT com WHERE NOT NULL, o Oracle consegue usar o índice (index fast full scan).

Minha pergunta: desde qual versão do Oracle esse comportamento está presente, é confiável (quando o índice de duas colunas é preferido) e por que não é mencionado com mais frequência (por exemplo , esta boa resposta não o menciona)?

Pequeno reprodutor

drop table SCOTT.T;
-- will not work with short rows (SELECT OWNER,SUBOBJECT_NAME ...)
create table SCOTT.T AS SELECT * FROM ALL_OBJECTS;
create index SCOTT.IDX_T_OWNER on SCOTT.T(OWNER); -- NOT NULL
-- (subobject_name,1) or (subobject_name,namespace) is NULL, NOT NULL
create index SCOTT.IDX_T_SUBOBJ on SCOTT.T(subobject_name); -- NULL
exec  dbms_stats.gather_table_stats(OWNNAME=>'SCOTT',TABNAME=>'T', cascade=>true );
desc SCOTT.T;

set autotrace on explain
-- fast index scan:
select distinct OWNER from SCOTT.T;
-- full table scan:
select distinct SUBOBJECT_NAME from SCOTT.T;
-- fast index scan:
select distinct SUBOBJECT_NAME from SCOTT.T where SUBOBJECT_NAME IS NOT NULL;

Aparência (em 18c) semelhante a:

select distinct subobject_name from T;

---------------------------------------------------------------------------
| Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------
|   0 | SELECT STATEMENT   |      |   715 |  1430 |   436   (3)| 00:00:01 |
|   1 |  HASH UNIQUE       |      |   715 |  1430 |   436   (3)| 00:00:01 |
|   2 |   TABLE ACCESS FULL| T    | 81426 |   159K|   428   (1)| 00:00:01 |
---------------------------------------------------------------------------


select distinct subobject_name from T where SUBOBJECT_NAME is not null;

------------------------------------------------------------------------------------
| Id  | Operation             | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT      |              |   624 |  1248 |     5  (20)| 00:00:01 |
|   1 |  HASH UNIQUE          |              |   624 |  1248 |     5  (20)| 00:00:01 |
|*  2 |   INDEX FAST FULL SCAN| IDX_T_SUBOBJ |  1459 |  2918 |     4   (0)| 00:00:01 |
------------------------------------------------------------------------------------

Quando tenho uma sessão em execução, psqlela não mostra tabelas recém-criadas (de outra conexão, mas para a função de proprietário atual).

Se eu logar novamente, eles aparecem. Preciso atualizar um cache psql de alguma forma ou isso está relacionado a transações/sessões ou permissões em cache?

No PostgreSQL 10 - ao usar um "usuário proprietário" (função de login que possui um esquema e todas as tabelas, não usado pelo aplicativo em tempo de execução) e um usuário "tempo de execução", posso GRANTselecionar/atualizar/excluir permissões em todas as tabelas existentes no esquema para o usuário de tempo de execução:

GRANT SELECT ON ALL TABLES IN SCHEMA owner TO runtime;

Mas isso se aplica apenas a objetos existentes e não a novas tabelas que podem ser criadas posteriormente.

Existe uma maneira de evitar a concessão de todos os novos objetos por meio da herança de funções ou permissões de esquema ou similares?

Eu estou querendo saber sobre índice não utilizado no MS SQL Server. Pelo uso do índice DMV posso identificar um índice que não foi usado para buscas, varreduras ou pesquisas.

No entanto, eu sei da Oracle que um índice pode não ser usado dessa maneira em um plano de execução, mas ainda pode contribuir com informações de estatísticas/cardinalidade para o otimizador (Oracle). Essa contribuição não é monitorada da mesma forma.

Então eu estou querendo saber se no MSSQL um índice pode ter um efeito positivo semelhante mesmo quando não é usado diretamente (em um período de tempo representativo)? E, especificamente, se puder ser melhor do que uma estatística de coluna (ou seja, descartar o índice seria prejudicial).

Eu não vi isso mencionado em nenhum dos artigos de ajuste de índice que encontrei, então presumo que o MSSQL (até 2017) não tenha esse conceito, está correto?

Estou procurando informações sobre extensões de reciclagem.

Ao descartar uma tabela, seus segmentos são renomeados para nomes gerados pelo sistema 'BIN$...' e as extensões são ocultadas.

Essas extensões ainda me impedirão de reduzir um arquivo de dados (ou tablespace)? Se assim for, eu gostaria de explicá-los no script.

Atualmente estou usando uma consulta inspirada no maxshrink.sql do AskTom:

select tbs.TABLESPACE_NAME, df.FILE_NAME,
    round(MAX(e.BLOCKS+e.BLOCK_ID+1)*tbs.BLOCK_SIZE/1024/1024,2) "MinMB",
    round(MAX(df.BYTES)/1024/1024,2) "FileMB"
  from DBA_TABLESPACES tbs
  LEFT JOIN DBA_DATA_FILES df on tbs.TABLESPACE_NAME = df.TABLESPACE_NAME
  LEFT JOIN DBA_EXTENTS e on df.FILE_ID = e.FILE_ID AND df.RELATIVE_FNO = e.RELATIVE_FNO
  -- WHERE
  --   tbs.TABLESPACE_NAME like 'MY%'
  GROUP BY df.FILE_ID, df.RELATIVE_FNO, tbs.TABLESPACE_NAME, tbs.BLOCK_SIZE, df.FILE_NAME
  ORDER BY 1,2;

Atualização : Inicialmente, minha pergunta também perguntou por que não vejo mais os segmentos 'BIN$' criados pelo Flashback Drop Table mais na versão 12.2. No entanto, isso foi um erro do meu lado, minhas tabelas de teste simplesmente não tinham segmentos para começar.

Em um cenário em que o Oracle Golden Gate é usado para replicar um site primário com um banco de dados Oracle RAC para um site secundário (e ativo/ativo de volta), suspeitamos de alterações inesperadas do site secundário não utilizado.

O problema é um pouco difícil de depurar, pois não temos acesso direto ao DBA. Gostaria de saber se existe uma maneira fácil com acesso SQL sem privilégios no lado primário para ver se alguma alteração é recebida do outro banco de dados?

Posso ver contadores ou timestamps de atividade OGG que me ajudem a rastrear DML feito?

Pelo que entendi, pude ver alterações do usuário OGG ao configurar gatilhos ou auditoria - no entanto, ambos não estão disponíveis nesta situação.

Quando olho para o plano de execução real de algumas de minhas consultas, percebo que as constantes literais usadas em uma cláusula WHERE aparecem como uma cadeia aninhada de varredura escalar e constante calculada .

Para reproduzir isso, eu uso a seguinte tabela

CREATE TABLE Table1 (
    [col1] [bigint] NOT NULL,
    [col2] [varchar](50) NULL,
    [col3] [char](200) NULL
)
CREATE NONCLUSTERED INDEX IX_Table1 ON Table1 (col1 ASC)

Com alguns dados nele:

INSERT INTO Table1(col1) VALUES (1),(2),(3),
                               (-9223372036854775808),
                               (9223372036854775807),
                               (2147483647),(-2147483648)

Quando executo a seguinte consulta (sem sentido):

SELECT a.col1, a.col2
  FROM Table1 a, Table1 b
  WHERE b.col1 > 2147483648

Vejo que ele fará um desenho de Loop Aninhado no resultado de Index Seek e um cálculo escalar (a partir de uma constante).

Observe que o literal é maior que maxint. Ajuda a escrever CAST(2147483648 as BIGINT). Alguma idéia de por que o MSSQL está adiando isso para o plano de execução e existe uma maneira mais curta de evitá-lo do que usar o elenco? Isso afeta os parâmetros vinculados às instruções preparadas (do jtds JDBC) também?

O cálculo escalar nem sempre é feito (parece ser específico de busca de índice ). E às vezes o analisador de consultas não mostra isso graficamente, mas como col1 < scalar(expr1000)nas propriedades do predicado.

Eu vi isso com o MS SSMS 2016 (13.0.16100.1) e SQL Server 2014 Expres Edition 64 bits no Windows 7, mas acho que é um comportamento geral.