Jacobm001's questions

Eu trabalho em uma equipe que tem uma configuração de SSRS com aproximadamente 1300 (e crescentes) relatórios enlatados. Como se pode imaginar, isso apresentou problemas quando uma mudança de quebra é introduzida em uma tabela. Encontrar todos os relatórios que podem tocar em uma tabela/campo é, na melhor das hipóteses, propenso a erros.

Estou tentando construir programaticamente um modelo de dependência. Obter o esquema Owner -> Object -> Fieldse como as visualizações/tabelas se relacionam é bastante trivial.

O que estou enfrentando é como obter uma lista resolvida de campos de uma determinada consulta. Posso extrair a consulta dos arquivos RDL, mas interpretar esses arquivos é muito menos. As consultas podem conter aliases para campos e tabelas, além de problemas como select *. Estou tentando evitar um hack regexp e realmente não quero escrever um interpretador SQL ...

Meu pensamento inicial foi percorrer os arquivos RDL e analisar a saída do plano de explicação. Embora tecnicamente possível, isso não me fornece uma lista completa de campos resolvidos.

Existe algum método no qual eu possa usar para fazer o banco de dados analisar uma determinada consulta e retornar uma lista de Object_Name.Field_Name? Não me importo de ter que fazer algum processamento de texto para extrair os resultados, se necessário.

Trabalho em uma equipe de desenvolvimento relativamente pequena que trabalha com um banco de dados Oracle (11g). Recentemente, foi solicitado que todos os desenvolvedores recebam a Advisorfunção para que possamos utilizar o SQL Tuning Advisor ao desenvolver consultas complexas. Alguns levantaram preocupações de que isso pode ter implicações significativas de desempenho e/ou segurança, mas não consegui encontrar respostas concretas para quais são essas implicações.

Se esse papel fosse dado aos vários membros da minha equipe, quais seriam as principais armadilhas que deveríamos estar atentos? Incluí a tag para Oracle 12c também, já que atualizaremos para ela em um futuro próximo. Se houver uma diferença significativa entre os dois, eu agradeceria se pelo menos fosse apontada.

Minha equipe usa Oracle 11 e SQL Developer. Ultimamente, tenho confiado muito em explicar planos para tentar determinar a maneira mais eficiente de resolver vários problemas. Recentemente, um colega de trabalho apontou que o plano de explicação nem sempre é preciso para o que realmente acontece no banco de dados e que um autotrace é uma indicação melhor, pois a consulta é realmente executada nos dados.

Testando uma consulta, obtive os seguintes resultados

_________________________________
|      Method        |   Cost   | 
|--------------------|----------|
| Query A Explain    |  306,188 |
| Query A Autotrace  |  399,131 |
| Query B Explain    |   99,226 |
| Query B Autotrace  |  137,661 |
|____________________|__________|

Ao utilizar o autotrace, a consulta A teve um aumento de custo de 30% e a consulta B de quase 40%. Obviamente, eu deveria estar usando a consulta b em ambos os casos, mas não entendo o que faz com que sejam diferentes.

Estou trabalhando com o Microsoft Reporting Services 2008. Em nosso banco de dados, temos um pequeno grupo de alunos confidenciais que precisam ser levados em consideração para diversas consultas. Se eles forem um aluno confidencial, o banco de dados precisa basicamente não retornar nada. Atualmente, fazemos algo ao longo das linhas de:

select
  case 
    when CONFIDENTIALITY_IND = 'Y' or :EmployeeClass = 'XA'
      then 'CONFIDENTIAL'
    else db.table.name
  end as name
from
  db.student

Isso não é grande coisa para uma consulta tão pequena, mas a maioria deles retorna muitos campos (geralmente mais de 20) e não sou fã de tantas instruções de caso por razões óbvias. Por causa de como o Reporting Services funciona, também não posso fazer uma substituição geral, ela deve ser feita em todos os campos.

Existe um método mais eficiente onde eu poderia substituir todos os valores na linha por 'Confidencial' em uma única declaração de caso, ou pelo menos algo mais elegante?

Edit: Para esclarecer, não existe apenas este campo no select. Escrevi apenas um para o exemplo, mas na produção, alguns relatórios procuram exibir uma grande quantidade de colunas. Estou tentando evitar fazer duas comparações em cada coluna para relatórios que podem retornar conjuntos de dados bastante grandes.

Em um relatório atual, estou tentando rastrear a migração de uma pessoa do departamento n, para n+1 ou para n+k.

Meus dados são divididos em uma linha por período (dados universitários). Um exemplo:

dept |  term
------------
   a | 20120
   a | 20121
   a | 20122
   b | 20123 -- <- person moved to new department
   b | 20130
   c | 20131 -- <- person moved to another new department
   a | 20132 -- <- person went back to a department they've already been in

usando a consulta

select 
  dept, 
  FIRST_VALUE(term) OVER (PARTITION BY dept ORDER BY term) as 
from
  table
order by term;

dá-me:

dept |  term
------------
   a | 20120
   a | 20120
   a | 20120
   b | 20123
   b | 20123
   c | 20131 
   a | 20120 -- <- notice this is the same as the above set of a's

Os a's duplicados no primeiro grupo e os b's no segundo grupo são devidos a outras linhas nos dados (estou bem com isso, mas remover isso seria um bônus). Meu principal problema é que preciso que o a final seja tratado como um grupo diferente; basicamente mostrando o primeiro cada vez que um cluster aparece.

Estou tentando descobrir quantas vezes em meu banco de dados ocorreu um agrupamento específico. Eu tenho duas tabelas relevantes.

mysql> describe logins;
+-------------+-------------+------+-----+---------------------+----------------+
| Field       | Type        | Null | Key | Default             | Extra          |
+-------------+-------------+------+-----+---------------------+----------------+
| id          | int(11)     | NO   | PRI | NULL                | auto_increment |
| username    | varchar(10) | NO   | MUL |                     |                |
| login_time  | datetime    | NO   | MUL | 0000-00-00 00:00:00 |                |
| logout_time | datetime    | YES  |     | NULL                |                |
| duration    | int(11)     | YES  |     | NULL                |                |
| location    | varchar(15) | YES  | MUL | NULL                |                |
+-------------+-------------+------+-----+---------------------+----------------+

e

mysql> describe login_apps;
+-------------+-------------+------+-----+---------+----------------+
| Field       | Type        | Null | Key | Default | Extra          |
+-------------+-------------+------+-----+---------+----------------+
| id          | int(11)     | NO   | PRI | NULL    | auto_increment |
| sid         | int(11)     | YES  |     | NULL    |                |
| programName | varchar(63) | YES  |     | NULL    |                |
| duration    | int(11)     | YES  |     | NULL    |                |
+-------------+-------------+------+-----+---------+----------------+

Digamos que eu queira saber quais aplicativos foram usados ​​em uma determinada sessão. Eu posso usar:

mysql> select distinct programName from login_apps where sid="35" and programName!="NULL";
+--------------------+
| programName        |
+--------------------+
| Acrobat  Distiller |
| FireFox            |
| Minitab 16         |
+--------------------+

para obter os nomes de programas distintos, mas estou interessado em saber com que frequência determinados grupos de aplicativos são usados ​​em uma determinada sessão. Então, basicamente, com que frequência esses três aplicativos são agrupados. Existe uma maneira que pode me obter resultados na forma de

application x-y-z, 12
application x-z, 9
application y-z, 7

Estou analisando um banco de dados de registros de login para uma universidade e estou tentando escrever uma consulta que me dê uma ideia de quantos usuários estão usando os laboratórios para períodos curtos, em vez de uma estadia mais longa.

Eu tenho a consulta abaixo da consulta, que me diz quantas vezes cada usuário usou um laboratório por menos ou igual a 10 minutos. O que eu quero é um resultado que me diga isso e o número total de logins.

select username, count(*) as "<= 10 min"
    from logins
    where duration<="600"
    group by username
    order by username asc
    limit 10;

Exemplo de saída desejada:

+----------+----------+----------+
| username | <=10 Min |  total   |
+----------+----------+----------+
| user1    |        4 |        7 |
| user2    |       11 |       22 |
| user3    |        1 |        3 |
| user4    |        4 |        8 |
+----------+----------+----------+

Em um banco de dados herdado, tenho duas tabelas de interesse atual recordse logins. loginme diz a localização do usuário e onde e quando seu login ocorreu (horários de entrada e saída incluídos).

A parte divertida é que não há marca de correlação entre a sessão de login e os aplicativos executados. Para resolver o problema, estou criando uma nova tabela login_appse tentando usar uma função para combinar as duas tabelas.

Até agora eu tenho:

drop function if exists ltop;
delimiter $$

create function ltop(id int, u varchar(10), s datetime, e datetime)
    returns text
    language sql
begin
    declare pid varchar(40);
    declare pname varchar(63);
    declare my_return varchar(100);
    declare cur1 cursor for (select usageProgramID 
                                from records 
                                where usageUser=u
                                    and usageWhen>=s 
                                    and usageWhen<=e
                                    and usageProgramID!="");
    open cur1;
    read_loop: loop
        fetch cur1 into pid;
        set pname = (select programName from Programs where programID=pid);
        insert into login_apps(`sid`, `programName`) values(id, pname);
    end loop read_loop;

    close cur1;

    return "finished";
end;$$
delimiter ;

Ele entra no sistema sem problemas e a inserção está funcionando conforme o esperado em um teste. O problema que estou apresentando é que, quando é executado como:

select ltop("265548", "user", "2013-02-21 13:54:27", "2013-02-21 14:32:18");

Eu recebo o erro:

ERROR 1329 (02000): No data - zero rows fetched, selected, or processed

Os dados a serem retornados não deveriam estar "concluídos"?

Em segundo lugar, não tenho muita certeza de qual seria a melhor maneira de executar isso em todos os valores de loginsquaisquer ponteiros para seguir essa rota.

Eu tenho uma consulta que está se comportando de maneira estranha. No meu banco de dados tenho uma tabela chamada "registros". Ele me dá um monte de informações sobre quais aplicativos um usuário executou nas máquinas da minha empresa. Estou tentando agregar algumas estatísticas, mas estou tendo alguns problemas estranhos com uma consulta.

Esta consulta é executada em cerca de 6,5 minutos (~30 milhões de entradas em "registros"). Eu esperaria que demorasse mais quando divisionName não fosse especificado, mas parece estar demorando um tempo irracional para terminar (da noite para o dia e ainda demorando).

select divisionName, programName, count(usageID) 
    from records R 
    right join Programs P 
        on P.programID=R.usageProgramID 
    right join locate L 
        on L.computerID=R.usageComputerID 
    where divisionName="umbrella"
    group by programName
    order by programName asc
    INTO OUTFILE '/tmp/lab_prog_umbrella.csv'
    FIELDS TERMINATED BY ','
    LINES TERMINATED BY '\n';

Existe uma estrutura alternativa para agilizar a consulta? Eu tenho um índice em (computerID,divisionName) em localizar e (programID,programName) em Programas, bem como uma infinidade de índices em registros.

Nota: Programas contém 4 campos e localização contém 2. Não acho que as junções sejam excepcionalmente grandes.

Editar:

Explique:

+----+-------------+-------+------+-----------------+-----------+---------+----------------------+------+----------------------------------------------+
| id | select_type | table | type | possible_keys   | key       | key_len | ref                  | rows | Extra                                        |
+----+-------------+-------+------+-----------------+-----------+---------+----------------------+------+----------------------------------------------+
|  1 | SIMPLE      | L     | ref  | loc             | loc       | 27      | const                | 1195 | Using where; Using temporary; Using filesort |
|  1 | SIMPLE      | R     | ref  | uprog,computers | computers | 34      | scf.L.computerID     | 1627 |                                              |
|  1 | SIMPLE      | P     | ref  | pid_name        | pid_name  | 43      | scf.R.usageProgramID |    1 | Using index                                  |
+----+-------------+-------+------+-----------------+-----------+---------+----------------------+------+----------------------------------------------+

Descrição dos registros:

+-----------------+-------------+------+-----+---------------------+-------+
| Field           | Type        | Null | Key | Default             | Extra |
+-----------------+-------------+------+-----+---------------------+-------+
| usageID         | varchar(24) | NO   | PRI | NULL                |       |
| usageWhen       | datetime    | NO   | PRI | 0000-00-00 00:00:00 |       |
| usageEnum       | int(11)     | YES  |     | NULL                |       |
| usageServerID   | int(11)     | YES  |     | NULL                |       |
| usageServerType | int(11)     | YES  |     | NULL                |       |
| usageProgramID  | varchar(40) | NO   | PRI |                     |       |
| usageLicenseID  | varchar(18) | YES  |     | NULL                |       |
| usageComputerID | varchar(31) | YES  | MUL | NULL                |       |
| usageExpansion  | varchar(0)  | YES  |     | NULL                |       |
| usageUser       | varchar(31) | YES  | MUL | NULL                |       |
| usageAddress    | varchar(28) | YES  |     | NULL                |       |
| usageGroup      | varchar(16) | YES  |     | NULL                |       |
| usageEvent      | int(11)     | YES  |     | NULL                |       |
| usageReason     | int(11)     | YES  |     | NULL                |       |
| usageTime       | int(11)     | YES  |     | NULL                |       |
| usageOtherTime  | varchar(25) | YES  |     | NULL                |       |
| usageGMTOffset  | int(11)     | YES  |     | NULL                |       |
| usageCount      | int(11)     | YES  |     | NULL                |       |
+-----------------+-------------+------+-----+---------------------+-------+

Descrição do local:

+--------------+-------------+------+-----+---------+-------+
| Field        | Type        | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| computerID   | varchar(31) | YES  | MUL | NULL    |       |
| divisionName | varchar(24) | YES  | MUL | NULL    |       |
+--------------+-------------+------+-----+---------+-------+

Descrição dos Programas:

+----------------+-------------+------+-----+---------+-------+
| Field          | Type        | Null | Key | Default | Extra |
+----------------+-------------+------+-----+---------+-------+
| programID      | varchar(40) | YES  | MUL | NULL    |       |
| programName    | varchar(63) | YES  | MUL | NULL    |       |
| programVersion | varchar(31) | YES  |     | NULL    |       |
| category       | varchar(30) | YES  |     | NULL    |       |
+----------------+-------------+------+-----+---------+-------+

Eu tenho um conjunto de dados realmente terrível que herdei e parte do meu trabalho é revisá-lo e limpá-lo para algo que seja realmente utilizável. Atualmente, estou tentando atualizar uma coluna em minha tabela com base no nome da entrada.

Tabela: (a categoria atualmente é nula para quase tudo)

+-----------------------------------------------------+
| programID | programName | programVersion | category |
+-----------------------------------------------------+

Minha consulta:

update Programs 
    set category="Adobe Suites" 
    where programName 
        in (
            select distinct programName 
                from Programs
                where programName regexp '^adobe.*cs[1-9]$'
            );

O problema é que não importa o que eu tente, continuo recebendo o erro:

ERRO 1093 (HY000): Você não pode especificar a tabela de destino 'Programas' para atualização na cláusula FROM

Não tenho certeza de que outra maneira isso poderia ser feito. Alguma ideia de como substituir a declaração from por outra coisa?

Eu tenho a seguinte consulta:

select programVersion, count(programVersion) 
     from records R 
     inner join Programs P 
         on P.programID=R.usageProgramID 
     where programName="word" 
     group by programVersion;

Resultados:

+----------------+-----------------------+
| programVersion | count(programVersion) |
+----------------+-----------------------+
| 12.0.0         |                     1 |
| 12.2.0         |                 32190 |
| 12.2.3         |                    20 |
| 12.2.6         |                  3990 |
| 12.2.8         |                 13128 |
| 12.3.1         |                   114 |
| 12.3.2         |                     4 |
| 12.3.4         |                    20 |
| 14.0.0         |                    57 |
| 14.1.0         |                 86587 |
| 14.1.3         |                    44 |
| 14.1.4         |                   728 |
| 14.2.0         |                    42 |
| 14.2.2         |                   130 |
| 14.2.3         |                 88219 |
| 14.2.5         |                    66 |
| 14.3.0         |                   126 |
| 14.3.1         |                    36 |
| 14.3.2         |                    74 |
+----------------+-----------------------+

Para este propósito, eu realmente não me importo com os incrementos de versão secundária. O que realmente me interessa são as diferenças nos incrementos principais. Existe uma maneira de obter os resultados combinados após o primeiro período?

Saída de Exemplo

+----------------+-----------------------+
| programVersion | count(programVersion) |
+----------------+-----------------------+
| 12             |         total of 12's |
| 14             |         total of 14's |
+----------------+-----------------------+

Estou tentando executar uma consulta em uma tabela para ver quantos usuários únicos têm um registro de uso no sistema em um determinado ponto. Eu tenho trabalhado com a seguinte consulta, mas ainda não vi um resultado adequado.

SELECT count(distinct usageUser), divisionName
FROM records R 
INNER JOIN locate L  
    ON L.computerID=R.usageComputerID
WHERE R.usageWhen LIKE "2012-07-08T12:%"
GROUP BY L.divisionName;

Atualmente, a consulta retorna 18, para cada divisão na tabela unida. Sem a GROUP BYcláusula, obtenho o mesmo número de registros.

EDIT: executei a consulta novamente, com sugestões de um comentário. Ao remover a cláusula group by and count, recebo isso (grande demais para postar). Esses dados estão muito mal formatados, infelizmente são herdados e bastante grandes.

Não é possível que esses usuários tenham usado todos os laboratórios listados.

Isso foi originalmente postado como falha do servidor e foi migrado para o StackOverFlow. Fui então apontado para cá dizendo que este pode ser o lugar mais apropriado para isso.