-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=81-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=192-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=201-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=263-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=150-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=70-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=158-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=2-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=236-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=124-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=169-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=92-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=215-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=30-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=141-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=58-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=99-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=245-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=?-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
) -- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide
-- =============================================-- OBJECTIF : Compter tous les prestataires situés dans une région,-- y compris ses départements, communes et quartiers.-- METHODE : Utilisation d'une CTE (Common Table Expression) récursive-- pour parcourir la hiérarchie géographique.-- =============================================-- Crée une table temporaire récursive nommée 'tem_hierarchy'-- Elle va stocker progressivement tous les niveaux de la hiérarchieWITHRECURSIVEtem_hierarchyAS (
-- =========================================-- ÉTAPE 1 : POINT DE DÉPART (ANCRAGE)-- Sélectionne la région racine (niveau 0)-- =========================================SELECTid,-- ID de la localisationname,-- Nom de la localisationtype,-- Type (région/département/commune/quartier)0ASlevel-- Niveau hiérarchique (0 = région)FROMpublic.localisationWHEREid=178-- ID de la localité-- =========================================-- UNION ALL combine les résultats avec...-- =========================================UNION ALL-- =========================================-- ÉTAPE 2 : RÉCURSION (DESCENTE DANS LA HIÉRARCHIE)-- Trouve tous les enfants du niveau précédent-- =========================================SELECTl.id,l.name,l.type,h.level+1-- Incrémente le niveau (+1 par rapport au parent)FROMpublic.localisationl-- Jointure avec la table de hiérarchie pour trouver les enfantsJOINpublic.localisation_hierarchielhONlh.child_id=l.id-- Lie l'enfant à sa localisation-- Jointure récursive : référence 'tem_hierarchy' elle-mêmeJOINtem_hierarchyhONlh.parent_id=h.id-- Lie l'enfant à son parent déjà exploré-- NOTE : PostgreSQL exécute cette boucle jusqu'à épuisement des niveaux
)
-- =============================================-- ÉTAPE 3 : COMPTAGE DES PRESTATAIRES-- Compte tous les prestataires liés aux localisations trouvées-- =============================================SELECTCOUNT(p.id) ascount_presta-- Résultat final : nombre de prestatairesFROMpublic.prestatairep-- Jointure avec la hiérarchie complèteINNER JOINtem_hierarchythONth.id=p.localisation_id-- Filtre les prestataires de la zone-- NOTE : INNER JOIN exclut les prestataires sans localisation valide;
-- Count les prestataires et prestations definit dans un domaine d'activite/*
SELECT COUNT(ad.id) as count, ad.name, ad.url_alias FROM public.activity_domain as ad
INNER JOIN public.prestataire_activity_domain as ptrad ON ptrad.activity_domain_id = ad.id
INNER JOIN public.prestataire as ptr ON ptr.id = ptrad.prestataire_id and ptr.status = true
INNER JOIN public.prestation as pti ON ptr.id = pti.prestataire_id and ptr.status = true
GROUP BY ad.id
ORDER BY ad.name ASC
limit :numbers offset 0
*/selectSUM(count_sub) ascount,mc.name,mc.url_alias,mc.idfrom (
-- prestatairesSELECTCOUNT(ptr.id) ascount_sub,ad.id,ad.name,ad.url_aliasFROMpublic.activity_domainasadINNER JOINpublic.prestataire_activity_domainasptradONptrad.activity_domain_id=ad.idINNER JOINpublic.prestataireasptrONptr.id=ptrad.prestataire_idANDptr.status=trueWHEREad.parent_idISNULLGROUP BYad.id,ad.name,ad.url_aliasUNION ALL-- prestationsSELECTCOUNT(pti.id) ascount_sub,ad.id,ad.name,ad.url_aliasFROMpublic.activity_domainasadINNER JOINpublic.prestationasptiONad.id=pti.activity_domain_idANDpti.status=trueWHEREad.parent_idISNULLGROUP BYad.id,ad.name,ad.url_alias
) mcGROUP BYmc.id,mc.name,mc.url_aliasORDER BYmc.nameASClimit?offset0
-- Count les prestataires et prestations definit dans un domaine d'activite/*
SELECT COUNT(ad.id) as count, ad.name, ad.url_alias FROM public.activity_domain as ad
INNER JOIN public.prestataire_activity_domain as ptrad ON ptrad.activity_domain_id = ad.id
INNER JOIN public.prestataire as ptr ON ptr.id = ptrad.prestataire_id and ptr.status = true
INNER JOIN public.prestation as pti ON ptr.id = pti.prestataire_id and ptr.status = true
GROUP BY ad.id
ORDER BY ad.name ASC
limit :numbers offset 0
*/selectSUM(count_sub) ascount,mc.name,mc.url_alias,mc.idfrom
(
-- prestatairesSELECTCOUNT(ptr.id) ascount_sub,ad.id,ad.name,ad.url_aliasFROMpublic.activity_domainasadINNER JOINpublic.prestataire_activity_domainasptradONptrad.activity_domain_id=ad.idINNER JOINpublic.prestataireasptrONptr.id=ptrad.prestataire_idANDptr.status=trueWHEREad.parent_idISNULLGROUP BYad.id,ad.name,ad.url_aliasUNION ALL-- prestationsSELECTCOUNT(pti.id) ascount_sub,ad.id,ad.name,ad.url_aliasFROMpublic.activity_domainasadINNER JOINpublic.prestationasptiONad.id=pti.activity_domain_idANDpti.status=trueWHEREad.parent_idISNULLGROUP BYad.id,ad.name,ad.url_alias
) mcGROUP BYmc.id,mc.name,mc.url_aliasORDER BYmc.nameASClimit?offset0
-- Count les prestataires et prestations definit dans un domaine d'activite/*
SELECT COUNT(ad.id) as count, ad.name, ad.url_alias FROM public.activity_domain as ad
INNER JOIN public.prestataire_activity_domain as ptrad ON ptrad.activity_domain_id = ad.id
INNER JOIN public.prestataire as ptr ON ptr.id = ptrad.prestataire_id and ptr.status = true
INNER JOIN public.prestation as pti ON ptr.id = pti.prestataire_id and ptr.status = true
GROUP BY ad.id
ORDER BY ad.name ASC
limit 20 offset 0
*/selectSUM(count_sub) ascount,mc.name,mc.url_alias,mc.idfrom (
-- prestatairesSELECTCOUNT(ptr.id) ascount_sub,ad.id,ad.name,ad.url_aliasFROMpublic.activity_domainasadINNER JOINpublic.prestataire_activity_domainasptradONptrad.activity_domain_id=ad.idINNER JOINpublic.prestataireasptrONptr.id=ptrad.prestataire_idANDptr.status=trueWHEREad.parent_idISNULLGROUP BYad.id,ad.name,ad.url_aliasUNION ALL-- prestationsSELECTCOUNT(pti.id) ascount_sub,ad.id,ad.name,ad.url_aliasFROMpublic.activity_domainasadINNER JOINpublic.prestationasptiONad.id=pti.activity_domain_idANDpti.status=trueWHEREad.parent_idISNULLGROUP BYad.id,ad.name,ad.url_alias
) mcGROUP BYmc.id,mc.name,mc.url_aliasORDER BYmc.nameASClimit?offset0;