União expressa que depende de outros resultados

Se entendi bem a pergunta, sua tarefa pode ser resolvida usando consultas recursivas. Oracle (consulte e SQLServer (2005 e superior) suportam isso. Certamente, diferentes fornecedores de RDMS usam uma sintaxe ligeiramente diferente.

Você quer dizer interseção? Considere relvars Customerse Orderscom uma correspondência onde um cliente tem zero, um ou muitos pedidos (eu não me referiria a isso como uma hierarquia, no entanto). Para encontrar clientes que têm pedidos:

( Customers { customer_ID } ) INTERSECT ( Orders { customer_ID } ) 

Eu suspeito que não é isso que você quer dizer, no qual, por favor, corrija sua pergunta para adicionar dados de exemplo e resultados esperados.

Não tenho certeza do que você quer dizer com UNIÃO. Por favor explique!

Se você está se referindo ao operador UNION que combina conjuntos de linhas "verticalmente", isso pode funcionar para você:

SELECT
   CASE X.Which WHEN 1 THEN A.Column1 ELSE B.Column1 END Column1,
   CASE X.Which WHEN 1 THEN A.Column2 ELSE B.Column2 END Column2,
   ...
FROM
   TableA A
   CROSS JOIN (
      SELECT 1
      UNION ALL SELECT 2
   ) X (Which)
   LEFT JOIN TableB B
      ON B.AId = A.Id
      AND X.Which = 2
WHERE
  X.Which = 1
  OR B.AId IS NOT NULL

Isso fará uma única operação de varredura em ambas as tabelas, em vez de pelo menos duas varreduras na tabela A para a seguinte consulta:

SELECT
   A.Column1,
   A.Column2,
   ...
FROM
   TableA A
UNION ALL
SELECT
   B.Column1,
   B.Column2,
   ...
FROM
   TableA A
   INNER JOIN TableB B
      ON B.AId = A.Id

Agora é possível quando você disse UNION que você simplesmente quis dizer uma interseção matemática, caso em que o último SELECT acima será o que você precisa - uma simples operação JOIN:

SELECT
   A.Whatever,
   B.Whatever,
   ...
FROM
   TableA A
   INNER JOIN TableB B
      ON B.AId = A.Id

ATUALIZAR

Aparentemente, alguns mecanismos de banco de dados têm recursos diferentes. Por exemplo, as duas últimas consultas no meu script de exemplo abaixo (supostamente) têm planos de execução muito diferentes no MySQL, mas são idênticas no SQL Server, que seleciona o melhor caminho de acesso alterando a ordem de junção, a posição de entrada esquerda/direita e movendo condições ao redor, conforme necessário. Não está preso fazendo JOINs primeiro e WHEREs depois.

Para apoiar minha afirmação sobre o servidor SQL, preparei alguns scripts de teste. Isso carrega uma tabela pai com 1 milhão de linhas e uma tabela filha com aproximadamente 2,5 milhões de linhas. As linhas individuais que estamos procurando são colocadas bem fundo na pilha (totalmente desnecessário, eu sei, mas ei, foi divertido).

CREATE DATABASE Proof;
GO
ALTER DATABASE Proof SET RECOVERY SIMPLE --no need to bloat the tran log
USE Proof;
GO
CREATE TABLE books (
   id int identity(1,1) NOT NULL CONSTRAINT PK_books PRIMARY KEY CLUSTERED,
   title varchar(100)
);

CREATE TABLE characters (
   book_id int not null constraint fk_characters foreign key references books (id),
   name varchar(100),
   CONSTRAINT PK_characters PRIMARY KEY CLUSTERED (book_id, name)
);

SET NOCOUNT ON;
DECLARE
   @book int,
   @rowcount int,
   @lastbookid int,
   @which int;

SET @book = Coalesce((SELECT Count(*) FROM books), 0);
SET @which = 1;
WHILE 1 = 1 BEGIN
   INSERT books
   SELECT Left(Replicate('-' + Convert(varchar(11), @book + v.number), 20), 100)
   FROM master.dbo.spt_values v
   WHERE   
      v.type = 'P'
      AND v.number < 1000000 - @book;

   SELECT @rowcount = @@rowcount, @lastbookid = scope_identity();
   IF @rowcount = 0 BREAK;
   SET @book = @book + @rowcount;

   INSERT characters
   SELECT
      B.id, Left(Replicate('|' + Convert(varchar(11), v.number), 20), 100)
   FROM
      books B
      CROSS JOIN master.dbo.spt_values v
   WHERE
      B.id BETWEEN @lastbookid - @rowcount + 1 AND @lastbookid
      AND v.type = 'P'
      AND v.number BETWEEN 1 AND Convert(int, Rand() * 4) + 1;


   IF @book >= 250000 AND @which = 1 BEGIN -- put them deep inside
      INSERT books VALUES ('The Frog and the Sorcerer');
      INSERT characters
      SELECT scope_identity(), name
      FROM (
          SELECT 'Frog' UNION ALL SELECT 'Sorcerer'
      ) x (name);
      SET @book = @book + 1;
      SET @which = @which + 1;
   END
   ELSE IF @book >= 500000 AND @which = 2 BEGIN
      INSERT books VALUES ('The Princess and the Pea');
      INSERT characters
      SELECT scope_identity(), name
      FROM (
          SELECT 'Princess' UNION ALL SELECT 'Pea'
      ) x (name);
      SET @book = @book + 1;
      SET @which = @which + 1;
   END
   ELSE IF @book >= 750000 AND @which = 3 BEGIN
      INSERT books VALUES ('Two Ways to Tango');
      INSERT characters
      SELECT scope_identity(), name
      FROM (
          SELECT 'Tango Alpha' UNION ALL SELECT 'Tango Omega'
      ) x (name);
      SET @book = @book + 1;
      SET @which = @which + 1;
   END;
END;
GO
SET SHOWPLAN_ALL ON;
GO
SELECT A.title,B.name
FROM
    books A
    LEFT JOIN characters B
        ON A.id = B.book_id
WHERE
    A.title IN ('Two Ways to Tango', 'The Frog and the Sorcerer')
OPTION (MAXDOP 1);
GO
SET SHOWPLAN_ALL OFF;
GO
SET SHOWPLAN_ALL ON;
GO
SELECT A.title, B.name
FROM
    (
        SELECT id, title FROM books A
        WHERE title IN ('Two Ways to Tango', 'The Frog and the Sorcerer')
    ) A
    LEFT JOIN characters B
        ON A.id = B.book_id
OPTION (MAXDOP 1);
GO
SET SHOWPLAN_ALL OFF;
GO
USE master;
GO
DROP DATABASE Proof;

Os dois planos de execução são idênticos. Suprimi o paralelismo porque era apenas ruído desnecessário (os planos ainda eram os mesmos). Aqui está o resultado do SHOWPLAN com a consulta removida (única parte que estava diferente).

StmtText                                                                                                                                                                                                                               StmtId NodeId Parent PhysicalOp           LogicalOp            Argument                                                                                                                                                                                               DefinedValues         EstimateRows EstimateIO EstimateCPU  AvgRowSize TotalSubtreeCost OutputList              Warnings Type     Parallel EstimateExecutions
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------ ------ ------ -------------------- -------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------- ------------ ---------- ------------ ---------- ---------------- ----------------------- -------- -------- -------- ------------------
                                                                                                                                                                                                                                       1      1      0      NULL                 NULL                 1                                                                                                                                                                                                      NULL                  2.994377     NULL       NULL         NULL       12.71991         NULL                    NULL     SELECT   0        1
  |--Nested Loops(Left Outer Join, OUTER REFERENCES:([A].[id]))                                                                                                                                                                        1      2      1      Nested Loops         Left Outer Join      OUTER REFERENCES:([A].[id])                                                                                                                                                                            NULL                  2.994377     0          0.0000125165 151        12.71991         [A].[title], [B].[name] NULL     PLAN_ROW 0        1
       |--Clustered Index Scan(OBJECT:([Proof].[dbo].[books].[PK_books] AS [A]), WHERE:([Proof].[dbo].[books].[title] as [A].[title]='The Frog and the Sorcerer' OR [Proof].[dbo].[books].[title] as [A].[title]='Two Ways to Tango')) 1      3      2      Clustered Index Scan Clustered Index Scan OBJECT:([Proof].[dbo].[books].[PK_books] AS [A]), WHERE:([Proof].[dbo].[books].[title] as [A].[title]='The Frog and the Sorcerer' OR [Proof].[dbo].[books].[title] as [A].[title]='Two Ways to Tango') [A].[id], [A].[title] 1            10.73646   1.100157     114        11.83662         [A].[id], [A].[title]   NULL     PLAN_ROW 0        1
       |--Clustered Index Seek(OBJECT:([Proof].[dbo].[characters].[PK_characters] AS [B]), SEEK:([B].[book_id]=[Proof].[dbo].[books].[id] as [A].[id]) ORDERED FORWARD)                                                                1      4      2      Clustered Index Seek Clustered Index Seek OBJECT:([Proof].[dbo].[characters].[PK_characters] AS [B]), SEEK:([B].[book_id]=[Proof].[dbo].[books].[id] as [A].[id]) ORDERED FORWARD                                                                [B].[name]            2.994377     0.003125   0.0001602938 50         0.003285294      [B].[name]              NULL     PLAN_ROW 0        0