TheLovelySausage's questions

Atualmente, estou tentando classificar os resultados de duas tabelas de forma que o campo de classificação primário seja um na tabela filho, mas gostaria de evitar que os resultados da tabela pai fossem movidos fora da sequência.

Um exemplo seriam as seguintes tabelas (usando o Ms SQL Server):

CREATE TABLE tier_a(
   idno INTEGER NOT NULL,
   name VARCHAR(10) NOT NULL
);

CREATE TABLE tier_b(
   idno INTEGER NOT NULL,
   tier_a_idno INTEGER NOT NULL,
   name VARCHAR(10) NOT NULL
);

INSERT INTO tier_a VALUES(3, 'C');
INSERT INTO tier_a VALUES(2, 'B');
INSERT INTO tier_a VALUES(1, 'A');

INSERT INTO tier_b VALUES(1, 1, 'A');
INSERT INTO tier_b VALUES(4, 2, 'C');
INSERT INTO tier_b VALUES(2, 1, 'B');
INSERT INTO tier_b VALUES(5, 3, 'A');
INSERT INTO tier_b VALUES(3, 1, 'C');

Se eu classificar apenas pela tabela filho:

SELECT tier_a.name AS tier_a_name, tier_b.name AS tier_b_name
FROM tier_a
JOIN tier_b ON tier_b.tier_a_idno = tier_a.idno
ORDER BY tier_b_name ASC

Eu consigo o que espero:

Ascending by child

tier_a_name | tier_b_name
C           | A
A           | A
A           | B
A           | C
B           | C

Descending by child

tier_a_name | tier_b_name
B           | C
A           | C
A           | B
C           | A
A           | A

Mas o que estou tentando alcançar é manter a ordem da tabela pai:

Ascending by child

tier_a_name | tier_b_name
A           | A
A           | B
A           | C
C           | A
B           | C

Descending by child

tier_a_name | tier_b_name
A           | C
A           | B
A           | A
B           | C
C           | A

Posso simular isso com um manual terrível ORDER BY:

Ascending by child

SELECT tier_a.name AS tier_a_name, tier_b.name AS tier_b_name
FROM tier_a
JOIN tier_b ON tier_b.tier_a_idno = tier_a.idno
ORDER BY
   CASE
      -- Parent of the Lowest tier_b name (A)
      WHEN tier_a.idno = 1 THEN 1
      -- Parent of the Lowest tier_b name (A) but Higher tier_a idno
      WHEN tier_a.idno = 3 THEN 2
      -- Parent of the Highest tier_b name (C)
      WHEN tier_a.idno = 2 THEN 3
   END,
   tier_b_name ASC

Descending by child

SELECT tier_a.name AS tier_a_name, tier_b.name AS tier_b_name
FROM tier_a
JOIN tier_b ON tier_b.tier_a_idno = tier_a.idno
ORDER BY
   CASE
      -- Parent of the Highest tier_b name (C)
      WHEN tier_a.idno = 1 THEN 1
      -- Parent of the Highest tier_b name (C) but Higher tier_a idno
      WHEN tier_a.idno = 2 THEN 2
      -- Parent of the Lowestest tier_b name (A)
      WHEN tier_a.idno = 3 THEN 3
   END,
   tier_b_name DESC

Gostaria de saber se é possível encontrar registros que só aparecem após a primeira ocorrência de uma cláusula where. Atualmente estou usando o PostgreSQL para este exemplo, mas seria preferível algo não específico do PostgreSQL.

Se eu tivesse uma tabela como esta para um exemplo

drop table if exists dummy;
create table dummy (
   col_a   varchar(10),
   col_b   varchar(10),
   col_c   varchar(10),
   test    integer
);

insert into dummy values
('A', 'B', 'C', 1),
('B', 'C', 'A', 2),
('C', 'A', 'B', 3),
('D', 'E', 'F', 4);

Se eu executar a consulta abaixo posso obter os dados em uma nova ordem

select * from dummy
order by col_b;

retornando

C | A | B | 3
A | B | C | 1
B | C | A | 2
D | E | F | 4

É possível fazer algo para que eu possa retornar apenas as linhas que ocorrem após uma determinada cláusula where, algo como

select * from dummy
/* where row appears after results 'A', 'B', 'C', 1 */
order by col_b;

Para obter

B | C | A | 2
D | E | F | 4

ATUALIZAR

O motivo pelo qual não estou usando where col_b > ?é porque não atende a valores duplicados

Funcionaria até que eu precisasse corresponder em uma coluna adicional como esta

select * from dummy
where col_b > 'B'
and col_c > 'C'
order by col_b;

Nesse caso, ele retornará a última linha porque ambos os valores estão acima do limite, mas não está cortando após a primeira ocorrência da linha especificada.

Estou tentando ter uma cláusula where que possa identificar a linha específica sendo linha

A | B | C | 1

Nesse caso

Estou usando o Informix DBEXPORT para despejar meu banco de dados, no entanto, ele usa | como seu delimitador padrão.

Sei que posso especificar o delimitador que gostaria de usar usando a variável de ambiente DBDELIMITER, mas como faço para defini-la para usar a guia

Eu tentei usar \t, mas isso não parece funcionar

(Está rodando em um CentOS 5 Server btw)

ATUALIZAR

verificando a documentação, diz que você pode especificar a guia usando CTRL-I, mas quando eu a defino como CTRL-I, ela aparece no arquivo unl como ^@

Esta é apenas uma pergunta muito simples antes de eu seguir em frente e destruir tudo.

Encomendei um servidor que terá o Windows Server 2016 instalado, mas agora percebi que as ferramentas que usaremos suportam apenas o SQL Server 2012.

Não tenho certeza, mas acho que o Windows Server e o SQL Server são entidades completamente separadas, então ainda seria bom instalar o SQL Server 2012 em uma máquina Windows Server 2016?