Avancée du GROUPE SQL PAR la requête

Imaginer qu'une ligne avec "catégorie, catégorie2" peut être transformé en deux lignes (une par "catégorie", l'un avec "catégorie2") pour obtenir ce que vous voulez. Vous auriez du le faire comme ceci:

SELECT items.category /* , other columns... */
FROM items
UNION ALL
SELECT items.category2 /* , other columns... */
FROM items

Donc, tout ce que vous devez faire est d'agréger ces:

SELECT category, count(*) FROM (
    SELECT items.category FROM items
    UNION ALL
    SELECT items.category2 FROM items
    ) expanded
GROUP BY category

Vous pouvez également faire la somme par étapes comme cela si votre base de données prend en charge:

with subcounts as (
  select items.category, items.category2, count(*) as subcount
  from items
  group by category, category2)
select category, sum(subagg) as finalcount from (
  select subcounts.category, sum(subcount) as subagg from subcounts group by category
  union all
  select subcounts.category2, sum(subcount) as subagg from subcounts group by category2
) combination
group by category

Cela permettra de limiter seulement à une analyse des principaux éléments de la table, bon si vous avez seulement un petit nombre de catégories. Vous pouvez émuler la même chose avec le temp des tables dans les bases de données qui ne supportent pas les "..."

EDIT:

J'étais sûr qu'il y avait une autre façon de le faire sans la numérisation d'Éléments deux fois, et il est. Eh bien, c'est la version de PostgreSQL:

SELECT category, count(*) FROM (
  SELECT CASE selector WHEN 1 THEN category WHEN 2 THEN category2 END AS category
  FROM Items, generate_series(1,2) selector
) items_fixed GROUP BY category

La seule postgresql-bit spécifique ici est "generate_series(1,2)" qui produit un "tableau" contenant deux rangées, l'une avec "1" et un "2". Ce qui est à mon humble avis l'une des caractéristique les plus utiles dans postgresql. Vous pouvez mettre en œuvre des choses similaires à SQL Server en tant que bien, bien sûr. Ou vous pourriez dire "(choisir 1 en tant que sélecteur union all select 2)". Une autre alternative est "(valeurs(1),(2)) de la série(sélecteur)" bien que la proportion de cette syntaxe est standard et combien est-postgres-spécifique, je ne suis pas sûr. Ces deux approches ont l'avantage de donner le planificateur d'une idée qu'il n'y aura que deux lignes.

De la croix-joindre à cette série, les éléments de tableau nous permet de générer des deux lignes de sortie pour chaque ligne de l'article. Vous pouvez même prendre que "items_fixed" sous-requête et d'en faire une vue -- qui btw, c'est l'inverse du processus, j'ai tendance à l'utiliser pour essayer de résoudre ce genre de problèmes.

OriginalL'auteur araqnid

im sûr qu'il y a une meilleure manière de le faire, mais ici ya aller

declare @group1 (Category1, Count int)
declare @group2 (Category2, Count int)

insert into @group1 (Category1, Count1)
select Category1, count(Category1)
from Table
group by Category1

insert into @group2 (Category2, Count2)
select Category2, count(Category2)
from Table
group by Category2

select 
coalesce(Category1, Category2) as Category,
coalesce(Count1,0) + coalesce(Count2,0) as CountAll
from @group1 a
    full outer join @group2 b
        on a.Category1=b.Category2

OriginalL'auteur DForck42